Changeset 4401


Ignore:
Timestamp:
30/10/08 16:49:30 (11 years ago)
Author:
pjkersha
Message:

ConfigFileParsers?.py: update to the way prefix is handled - if set filter out all params without this prefix
ndg.security.common.logService: removed - old code
SessionManager?: near to completion of refactoring for generic AuthN interface

Location:
TI12-security/trunk/python
Files:
1 deleted
11 edited
2 moved

Legend:

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

    r4397 r4401  
    349349            self.parseConfig(cfg, section=cfgFileSection, prefix=cfgPrefix) 
    350350 
    351         # Update attributes from keywords passed 
     351        # Update attributes from keywords passed - set user private key 
     352        # password first if it's present.  This is to avoid an error setting 
     353        # the private key 
     354        self.userPriKeyPwd = kw.pop('userPriKeyPwd', None) 
    352355        for k,v in kw.items(): 
    353356            setattr(self, k, v) 
     
    436439        # Copy prop dict into object attributes - __slots__ definition and  
    437440        # property methods will ensure only the correct attributes are set 
     441        # Set user private key password first if it's present.  This is to  
     442        # avoid an error setting the private key 
     443        self.userPriKeyPwd = prop.pop('userPriKeyPwd', None) 
    438444        for key, val in prop.items(): 
    439445            setattr(self, key, val) 
     
    10431049            # Request a new attribute certificate from the Attribute 
    10441050            # Authority 
    1045             log.debug('CredentialWallet._getAttCert for user "%s" ' 
    1046                       'and service: "%s" ...' % (userId,  
    1047                                 attributeAuthorityURI or attributeAuthority)) 
     1051            log.debug('CredentialWallet._getAttCert for service: "%s" ...' %  
     1052                      attributeAuthorityURI or attributeAuthority) 
    10481053                 
    10491054            attCert = attributeAuthorityClnt.getAttCert(userId=userId, 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/utils/ConfigFileParsers.py

    r4320 r4401  
    9494                        propBranch = properties[section] 
    9595                         
    96                     if prefix: 
    97                         propBranch = propBranch[prefix] 
    98      
    9996                    validateProperties(propBranch, validKeys) 
    10097                    _setDefaultValues(propBranch, validKeys) 
    10198                     
    10299            else: 
    103                 if prefix is not None: 
    104                     propBranch = properties[prefix] 
    105                 else: 
    106                     propBranch = properties 
    107                      
    108100                validateProperties(properties, validKeys) 
    109101                _setDefaultValues(properties, validKeys) 
     
    184176                raise IOError('Error parsing properties file "%s": No such ' 
    185177                              'file' % propFilePath) 
    186             
     178        else: 
     179            self.cfg = cfg 
     180                
    187181        properties = {} 
    188182         
     
    264258 
    265259    propRoot = {} 
    266     prefixDot = prefix + '.' 
     260    propThisBranch = propRoot 
    267261     
    268262    if section == 'DEFAULT': 
     
    284278        # Allow for prefixes - 1st a prefix global to all parameters 
    285279        keyLevels = key.split('.') 
    286         if keyLevels[0] == prefix: 
    287             keyLevels = keyLevels[1:] 
    288             if keyLevels == []: 
    289                 raise ConfigFileParseError('Expecting "%s.<option>"; got "%s"'% 
    290                                            ((prefix,)*2)) 
    291                  
    292             # Add a sub-section for this prefix 
    293             if prefix not in propRoot: 
    294                 propRoot[prefix] = {} 
    295              
    296             propThisBranch = propRoot[prefix] 
    297         else: 
    298             propThisBranch = propRoot 
    299                 
     280        if prefix: 
     281            if keyLevels[0] == prefix: 
     282                keyLevels = keyLevels[1:] 
     283                if keyLevels == []: 
     284                    raise ConfigFileParseError('Expecting "%s.<option>"; got ' 
     285                                               '"%s"' % ((prefix,)*2)) 
     286            else: 
     287                continue            
     288                    
    300289        # 2nd - prefixes to denote sections 
    301290        if len(keyLevels) > 1: 
     
    306295            subSectionKey = keyLevels[0] 
    307296            subKey = '_'.join(keyLevels[1:]) 
    308             if subSectionKey in validKeys: 
     297            if subSectionKey in validKeys and \ 
     298               isinstance(validKeys[subSectionKey], dict): 
    309299                val = _parseVal(cfg, section, key, validKeys[subSectionKey], 
    310300                                subKey=subKey) 
     
    370360            continue 
    371361        except Exception, e: 
    372             # TODO: Remove catch - testing only 
    373             pass 
     362            log.error('Error parsing option "%s" in section "%s": %s' % 
     363                      (section, key, e)) 
     364            raise 
    374365 
    375366    raise ValueError('Error parsing option "%s" in section "%s"'%(section,key)) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/attributeauthority.py

    r4377 r4401  
    258258        if section != 'DEFAULT': 
    259259            propBranch = propBranch[section] 
    260              
    261         if prefix: 
    262             propBranch = propBranch[prefix] 
    263260             
    264261        self.__prop = propBranch 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/authnservice/basicauthn.py

    r4384 r4401  
    2626     
    2727    def __init__(self, **prop): 
    28         '''Instantiate MyProxy client object taking in settings from the  
    29         properties file''' 
     28        '''Instantiate object taking in settings from the input 
     29        properties''' 
    3030        accounts = prop.get('basicAuthN_accounts', []).split() 
    3131        self.accounts = dict([tuple(account.split(':')) \ 
     
    3333        
    3434    def logon(self, username, passphrase): 
    35         '''Implementation of AbstractAuthNService logon for a MyProxy client 
     35        '''Implementation of AbstractAuthNService logon 
    3636        @type username: basestring 
    3737        @param username: username for account login 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/sessionmanager.py

    r4397 r4401  
    3939from ndg.security.common.credentialwallet import CredentialWallet, \ 
    4040    CredentialRepository, CredentialWalletError, \ 
    41     CredentialWalletAttributeRequestDenied 
     41    CredentialWalletAttributeRequestDenied, NullCredentialRepository 
    4242     
    4343from ndg.security.common.wssecurity import WSSecurityConfig 
     
    8484    sessIdLen = 32 
    8585     
    86     def __init__(self, **credWalletKeys): 
     86    def __init__(self, **credentialWalletKeys): 
    8787        """Initialise UserSession with keywords to CredentialWallet""" 
    8888                 
     
    9393        self.__sessIdList = [] 
    9494        self.addNewSessID() 
    95         self.__credWallet = CredentialWallet(**credWalletKeys) 
     95        self.__credentialWallet = CredentialWallet(**credentialWalletKeys) 
    9696 
    9797        log.info("Created a session with ID = %s" % self.__sessIdList[-1]) 
     
    9999    def __getCredentialWallet(self): 
    100100        """Get Credential Wallet instance""" 
    101         return self.__credWallet 
    102      
    103     credWallet = property(fget=__getCredentialWallet, 
     101        return self.__credentialWallet 
     102     
     103    credentialWallet = property(fget=__getCredentialWallet, 
    104104                          doc="Read-only access to CredentialWallet instance") 
    105105 
     
    233233    value indicates the default if not present in the file""" 
    234234 
    235     # valid configuration property keywords 
    236     AUTHN_KEYNAME = 'authNService' 
    237     CREDREPOS_KEYNAME = 'credentialRepository' 
     235    # Valid configuration property keywords 
     236    AUTHN_KEYNAME = 'authNService'    
     237    CREDREPOS_KEYNAME = 'credentialRepository'     
    238238    CREDWALLET_KEYNAME = 'credentialWallet' 
    239239    defaultSectionName = 'sessionManager' 
    240240     
    241241    authNServicePropertyDefaults = { 
    242         'modFilePath': None, 
    243         'modName': None, 
     242        'moduleFilePath': None, 
     243        'moduleName': None, 
    244244        'className': None, 
    245         'propertiesFile': None         
    246245    } 
    247246     
    248247    credentialRepositoryPropertyDefaults = { 
    249         'modFilePath': None, 
    250         'modName': None, 
     248        'moduleFilePath': None, 
     249        'moduleName': None, 
    251250        'className': None, 
    252         'propertiesFile': None 
    253251    } 
    254252 
     
    260258        'sslCACertDir':           None, 
    261259        AUTHN_KEYNAME:            authNServicePropertyDefaults,  
    262         CREDWALLET_KEYNAME:       CredentialWallet.propertyDefaults, 
    263260        CREDREPOS_KEYNAME:        credentialRepositoryPropertyDefaults 
    264261    } 
     
    313310        self.readProperties() 
    314311 
     312         
     313        # Set any properties that were provided by keyword input 
     314        # NB If any are duplicated with tags in the properties file they 
     315        # will overwrite the latter 
     316        self.setProperties(**prop) 
     317 
    315318        # Instantiate the authentication service to use with the session  
    316319        # manager 
    317         authNModFilePath=self.__prop[self.AUTHN_KEYNAME].get('moduleFilePath') 
    318         self.__authNService = instantiateClass( 
    319                             self.__prop[self.AUTHN_KEYNAME].get('moduleName'), 
    320                             self.__prop[self.AUTHN_KEYNAME].get('className'), 
    321                             moduleFilePath=authNModFilePath, 
    322                             objectType=AbstractAuthNService,  
    323                             classProperties=self.__prop[self.AUTHN_KEYNAME]) 
     320        self.initAuthNService() 
    324321         
    325322        # Call here as we can safely expect that all Credential Repository 
    326323        # parameters have been set above 
    327         credentialRepositoryModule = \ 
    328             self.__prop[self.CREDREPOS_KEYNAME].get('modName') 
    329         credentialRepositoryClassName = \ 
    330             self.__prop[self.CREDREPOS_KEYNAME].get('className') 
     324        self.initCredentialRepository()     
     325         
     326         
     327    def initAuthNService(self): 
     328        '''Load Authentication Service Interface from property settings''' 
     329        authNProp = self.__prop[SessionManager.AUTHN_KEYNAME] 
     330        authNModFilePath = authNProp.get('moduleFilePath') 
     331         
     332        self.__authNService = instantiateClass(authNProp.get('moduleName'), 
     333                                               authNProp.get('className'), 
     334                                               moduleFilePath=authNModFilePath, 
     335                                               objectType=AbstractAuthNService,  
     336                                               classProperties=authNProp)             
     337         
     338    def initCredentialRepository(self): 
     339        '''Load Credential Repository instance from property settings 
     340        If non module or class name were set a null interface is loaded by 
     341        default''' 
     342        credReposProp = self.__prop[SessionManager.CREDREPOS_KEYNAME] 
     343        credentialRepositoryModule = credReposProp.get('moduleName') 
     344        credentialRepositoryClassName = credReposProp.get('className') 
    331345             
    332346        if credentialRepositoryModule is None or \ 
     
    334348            self._credentialRepository = NullCredentialRepository() 
    335349        else: 
    336             credentialRepositoryModuleFilePath = \ 
    337                 self.__prop[self.CREDREPOS_KEYNAME].get('modFilePath') 
     350            credReposModuleFilePath = credReposProp.get('moduleFilePath') 
    338351                 
    339352            self._credentialRepository = instantiateClass( 
    340                         credentialRepositoryModule, 
    341                         credentialRepositoryClassName, 
    342                         moduleFilePath=credentialRepositoryModuleFilePath, 
    343                         objectType=CredentialRepository, 
    344                         classProperties=self.__prop[self.CREDREPOS_KEYNAME]) 
    345          
    346         # Set any properties that were provided by keyword input 
    347         # NB If any are duplicated with tags in the properties file they 
    348         # will overwrite the latter 
    349         self.setProperties(**prop) 
    350          
    351 #    def __repr__(self): 
    352 #        """Return file properties dictionary as representation""" 
    353 #        return repr(self.__prop) 
     353                                        credentialRepositoryModule, 
     354                                        credentialRepositoryClassName, 
     355                                        moduleFilePath=credReposModuleFilePath, 
     356                                        objectType=CredentialRepository, 
     357                                        classProperties=credReposProp) 
    354358 
    355359    def __delitem__(self, key): 
     
    358362     
    359363    def __getitem__(self, key): 
    360         self.__class__.__name__ + """ behaves as data dictionary of Session 
    361         Manager properties 
     364        """Enables behaviour as data dictionary of Session Manager properties 
    362365        """ 
    363366        if key not in self.__prop: 
     
    365368         
    366369        return self.__prop[key] 
    367      
    368370     
    369371    def __setitem__(self, key, item): 
     
    376378 
    377379    def clear(self): 
    378         raise KeyError("Data cannot be cleared from "+self.__class__.__name__) 
     380        raise KeyError("Data cannot be cleared from "+SessionManager.__name__) 
    379381    
    380382    def keys(self): 
     
    552554        # Configuration file properties are held together in a dictionary 
    553555        readPropertiesFile = INIPropertyFileWithValidation() 
    554         fileProp = readPropertiesFile(self.propFilePath, 
    555                                       validKeys=SessionManager.propertyDefaults, 
    556                                       prefix=prefix, 
    557                                       sections=(section,)) 
    558          
    559         # Keep a copy of the config file for the CredentialWallet to reference so  
    560         # that it can retrieve WS-Security settings 
     556        fileProp=readPropertiesFile(self.propFilePath, 
     557                                    validKeys=SessionManager.propertyDefaults, 
     558                                    prefix=prefix, 
     559                                    sections=(section,)) 
     560         
     561        # Keep a copy of the config file for the CredentialWallet to reference  
     562        # so that it can retrieve WS-Security settings 
    561563        self._cfg = readPropertiesFile.cfg 
    562564         
     
    567569            propBranch = propBranch[section] 
    568570             
    569         if prefix: 
    570             propBranch = propBranch[prefix] 
    571              
    572571        self.__prop = propBranch 
    573572 
    574573        log.info('Loaded properties from "%s"' % self.propFilePath) 
    575         
     574 
     575    @staticmethod 
     576    def _setProperty(value): 
     577        if value and isinstance(value, basestring): 
     578            return os.path.expandvars(value).strip() 
     579        else: 
     580            return value               
     581         
    576582    def setProperties(self, **prop): 
    577583        """Update existing properties from an input dictionary 
     
    582588        for key in prop.keys(): 
    583589            if key not in self.propertyDefaults: 
    584                 raise SessionManagerError("Property name \"%s\" is invalid" % key) 
    585         for key, value in prop.items(): 
     590                raise SessionManagerError('Property name "%s" is invalid'%key) 
     591             
     592        for key, value in prop.iteritems(): 
    586593                        
    587             if key == 'authNProp': 
    588                 self.__authNService.setProperties(prop[key]) 
    589      
    590             elif key == self.CREDREPOS_KEYNAME: 
    591                 self.__prop[self.CREDREPOS_KEYNAME] = prop[key].copy() 
    592  
    593             elif key in self.propertyDefaults: 
     594            if key == SessionManager.AUTHN_KEYNAME: 
     595                for subKey, subVal in prop[key].iteritems(): 
     596#                    if subKey not in \ 
     597#                       SessionManager.authNServicePropertyDefaults: 
     598#                        raise SessionManagerError('Key "%s" is not a valid ' 
     599#                                            'Session Manager AuthNService ' 
     600#                                            'property' % subKey) 
     601#                         
     602                    if subVal: 
     603                        self.__prop[key][subKey] = SessionManager._setProperty( 
     604                                                                        subVal) 
     605     
     606            elif key == SessionManager.CREDREPOS_KEYNAME: 
     607                for subKey, subVal in self.__prop[key].iteritems(): 
     608#                    if subKey not in \ 
     609#                       SessionManager.credentialRepositoryPropertyDefaults: 
     610#                        raise SessionManagerError('Key "%s" is not a valid ' 
     611#                                        'Session Manager credentialRepository ' 
     612#                                        'property' % subKey) 
     613#                         
     614                    if subVal: 
     615                        self.__prop[key][subKey] = SessionManager._setProperty( 
     616                                                                        subVal) 
     617 
     618            elif key in SessionManager.propertyDefaults: 
    594619                # Only update other keys if they are not None or "" 
    595620                if value: 
    596                     if isinstance(value, basestring): 
    597                         self.__prop[key] = os.path.expandvars(value).strip() 
    598                     else: 
    599                         self.__prop[key] = value               
     621                    self.__prop[key] = SessionManager._setProperty(value)              
    600622            else: 
    601623                raise SessionManagerError('Key "%s" is not a valid Session ' 
    602                                       'Manager property' % key) 
     624                                          'Manager property' % key) 
    603625         
    604626    def getSessionStatus(self, sessID=None, userDN=None): 
     
    652674                username=None, 
    653675                passphrase=None,  
    654                 userCert=None,  
     676                userX509Cert=None,  
    655677                sessID=None):         
    656678        """Create a new user session or connect to an existing one: 
    657679 
    658680        connect([createServerSess=True/False, ]|[, username=u, passphrase=p]| 
    659                 [, userCert=px]|[, sessID=id]) 
     681                [, userX509Cert=px]|[, sessID=id]) 
    660682 
    661683        @type createUserSess: bool 
     
    671693        @param passphrase: pass-phrase - user with username arg 
    672694         
    673         @type userCert: string 
    674         @param userCert: connect to existing session with proxy certificate 
     695        @type userX509Cert: string 
     696        @param userX509Cert: connect to existing session with proxy certificate 
    675697        corresponding to user.  username/pass-phrase not required 
    676698         
     
    688710         
    689711        # Initialise proxy cert to be returned 
    690         userCert = None 
     712        userX509Cert = None 
    691713         
    692714        if sessID is not None:             
     
    694716            # return equivalent proxy cert 
    695717            userSess = self._connect2UserSession(sessID=sessID) 
    696             userCert = userSess.credWallet.userX509Cert 
    697              
    698         elif userCert is not None: 
     718            userX509Cert = userSess.credentialWallet.userX509Cert 
     719             
     720        elif userX509Cert is not None: 
    699721            # Connect to an existing session identified by a proxy  
    700722            # certificate  
    701             userSess = self._connect2UserSession(userCert=userCert) 
     723            userSess = self._connect2UserSession(userX509Cert=userX509Cert) 
    702724            sessID = userSess.latestSessID 
    703725             
     
    709731                userCreds = self.__authNService.logon(username, passphrase) 
    710732            except AuthNServiceError: 
    711                 # Filter out known AuthNService execptions 
    712                  
     733                # Filter out known AuthNService exceptions 
    713734                raise 
    714735            except Exception, e: 
     
    718739                raise AuthNServiceError("Authentication Service: %s" % e) 
    719740                             
    720             # unpack output 
     741            # Unpack output 
    721742            if userCreds is None: 
    722743                nUserCreds = 0 
     
    725746                 
    726747            if nUserCreds > 1: 
    727                 userCert = userCreds[0] 
     748                userX509Cert = userCreds[0] 
    728749                userPriKey = userCreds[1] 
    729750            else: 
    730                 userCert = userPriKey = None 
    731                  
    732             # Issuing cert is needed only if userCert is a proxy 
     751                userX509Cert = userPriKey = None 
     752                 
     753            # Issuing cert is needed only if userX509Cert is a proxy 
    733754            issuingCert = nUserCreds > 2 and userCreds[2] or None         
    734755 
    735756            if createServerSess: 
    736757                # Session Manager creates and manages user's session 
    737                 userSess = self._createUserSession(username, userCreds) 
     758                userSess = self._createUserSession(username,  
     759                                                   passphrase, 
     760                                                   userCreds) 
    738761                sessID = userSess.latestSessID 
    739762            else: 
     
    741764                                 
    742765        # Return proxy details and cookie 
    743         return userCert, userPriKey, issuingCert, sessID         
     766        return userX509Cert, userPriKey, issuingCert, sessID         
    744767         
    745768        
    746     def _createUserSession(self, username, userCreds=None): 
     769    def _createUserSession(self, username, userPriKeyPwd=None, userCreds=None): 
    747770        """Create a new user session from input user credentials        
    748771        and return 
     
    750773        @type username: basestring 
    751774        @param username: username user logged in with 
     775        @type userPriKeyPwd: basestring 
     776        @param userPriKeyPwd: password protecting the private key if set. 
    752777        @type userCreds: tuple 
    753778        @param userCreds: tuple containing user certificate, private key 
     
    776801            # Copy global Credential Wallet settings into specific set for this 
    777802            # user 
    778             credWalletKw = self.__prop['credentialWallet'].copy() 
    779             credWalletKw['userId'] = username 
    780              
     803            if self.propPrefix: 
     804                credentialWalletPropPfx = '.'.join((self.propPrefix,  
     805                                            SessionManager.CREDWALLET_KEYNAME)) 
     806            else: 
     807                credentialWalletPropPfx = SessionManager.CREDWALLET_KEYNAME 
     808                 
     809            # Include cfg setting to enable WS-Security Signature handler to  
     810            # pick up settings 
     811            credentialWalletProp = { 
     812                'cfg': self._cfg, 
     813                'userId': username, 
     814                'userPriKeyPwd': userPriKeyPwd, 
     815                'credentialRepository': self._credentialRepository, 
     816                'cfgPrefix': credentialWalletPropPfx 
     817            } 
     818                                                     
     819     
    781820            # Update user PKI settings if any are present 
    782821            if userCreds is None: 
     
    786825                 
    787826            if nUserCreds > 1: 
    788                 credWalletKw['userX509Cert'] = userCreds[0] 
    789                 credWalletKw['userPriKey'] = userCreds[1] 
     827                credentialWalletProp['userX509Cert'] = userCreds[0] 
     828                credentialWalletProp['userPriKey'] = userCreds[1] 
    790829             
    791830            if nUserCreds == 3: 
    792                 credWalletKw['issuingX509Cert'] = userCreds[2] 
     831                credentialWalletProp['issuingX509Cert'] = userCreds[2] 
    793832                 
    794833            try:    
    795                 userSess = UserSession(**credWalletKw)      
     834                userSess = UserSession(**credentialWalletProp)      
    796835            except Exception, e: 
    797836                log.error("Error occurred whilst creating User Session: %s"%e) 
     
    805844                     
    806845                except Exception, e: 
    807                     log.error("Parsing input certificate DN for session create: " 
    808                               "%s" % e) 
     846                    log.error("Parsing input certificate DN for session " 
     847                              "create: %s" % e) 
    809848                    raise 
    810849 
     
    815854        # Check for unique session ID 
    816855        if newSessID in self.__sessDict: 
    817             raise SessionManagerError("New Session ID is already in use:\n\n %s" %  
    818                                   newSessID) 
     856            raise SessionManagerError("New Session ID is already in use:\n\n " 
     857                                      "%s" % newSessID) 
    819858 
    820859        # Add new session to list                  
     
    825864 
    826865 
    827     def _connect2UserSession(self, username=None, userX509Cert=None, sessID=None): 
     866    def _connect2UserSession(self,username=None,userX509Cert=None,sessID=None): 
    828867        """Connect to an existing session by providing a valid session ID or 
    829868        proxy certificate 
     
    853892 
    854893            log.info("Connecting to session userDN=%s; sessID=%s using " 
    855                      "username=%s" % (userSess.credWallet.userX509Cert.dn,  
    856                                       userSess.sessIdList, 
    857                                       username))             
     894                     "username=%s"%(userSess.credentialWallet.userX509Cert.dn,  
     895                                    userSess.sessIdList, 
     896                                    username))             
    858897        elif sessID: 
    859898            userSess = self.__sessDict.get(sessID) 
     
    862901                raise SessionNotFound("No user session found matching input " 
    863902                                      "session ID") 
    864  
     903            if userSess.credentialWallet.userX509Cert: 
     904                userDN = userSess.credentialWallet.userX509Cert.dn 
     905            else: 
     906                userDN = None 
     907                 
    865908            log.info("Connecting to session userDN=%s; username=%s using " 
    866                      "sessID=%s" % (userSess.credWallet.userX509Cert.dn,  
    867                                     username, 
    868                                     userSess.sessIdList)) 
     909                     "sessID=%s" % (userDN, username, userSess.sessIdList)) 
    869910 
    870911        elif userX509Cert is not None: 
     
    894935            log.info("Connecting to session sessID=%s; username=%s using " 
    895936                     "userDN=%s" % (userSess.sessIdList,  
    896                                     userSess.credWallet.username,  
     937                                    userSess.credentialWallet.username,  
    897938                                    userDN)) 
    898939        else: 
    899             raise SessionManagerError('"username", "sessID" or "userX509Cert" keywords ' 
    900                                   'must be set') 
     940            raise SessionManagerError('"username", "sessID" or "userX509Cert" ' 
     941                                      'keywords must be set') 
    901942             
    902943        # Check that the Credentials held in the wallet are still valid             
    903944        try: 
    904             userSess.credWallet.isValid(raiseExcep=True) 
     945            userSess.credentialWallet.isValid(raiseExcep=True) 
    905946            return userSess 
    906947         
     
    914955            # ! Delete user session since it's user certificate is invalid 
    915956            self.deleteUserSession(userSess=userSess) 
    916             raise UserSessionExpired, "User session is invalid: %s" % e           
     957            raise UserSessionExpired("User session is invalid: %s" % e)        
    917958         
    918959        except Exception, e: 
    919             raise InvalidUserSession, "User session is invalid: %s" % e 
    920                  
    921  
    922     def deleteUserSession(self, sessID=None, userCert=None, userSess=None): 
     960            raise InvalidUserSession("User session is invalid: %s" % e) 
     961                 
     962 
     963    def deleteUserSession(self, sessID=None, userX509Cert=None, userSess=None): 
    923964        """Delete an existing session by providing a valid session ID or 
    924965        proxy certificate - use for user logout 
    925966 
    926         deleteUserSession([userCert]|[sessID]|[userSess]) 
    927          
    928         @type userCert: ndg.security.common.X509.X509Cert  
    929         @param userCert: proxy certificate corresponding to an existing  
     967        deleteUserSession([userX509Cert]|[sessID]|[userSess]) 
     968         
     969        @type userX509Cert: ndg.security.common.X509.X509Cert  
     970        @param userX509Cert: proxy certificate corresponding to an existing  
    930971        session to connect to. 
    931972         
     
    951992            # Get associated user Distinguished Name if a certificate has been 
    952993            # set 
    953             if userSess.credWallet.userX509Cert is None: 
     994            if userSess.credentialWallet.userX509Cert is None: 
    954995                userDN = None 
    955996            else: 
    956                 userDN = str(userSess.credWallet.userX509Cert.dn) 
    957              
    958         elif userCert: 
     997                userDN = str(userSess.credentialWallet.userX509Cert.dn) 
     998             
     999        elif userX509Cert: 
    9591000            try: 
    960                 userDN = str(userCert.dn) 
     1001                userDN = str(userX509Cert.dn) 
    9611002                 
    9621003            except Exception, e: 
     
    9711012                                          "input user certificate")         
    9721013        elif userSess: 
    973             if userSess.credWallet.userX509Cert is None: 
     1014            if userSess.credentialWallet.userX509Cert is None: 
    9741015                userDN = None 
    9751016            else: 
    976                 userDN = str(userSess.credWallet.userX509Cert.dn) 
     1017                userDN = str(userSess.credentialWallet.userX509Cert.dn) 
    9771018        else: 
    9781019            # User session not found with given ID 
    979             raise SessionManagerError('"sessID", "userCert" or "userSess" ' 
     1020            raise SessionManagerError('"sessID", "userX509Cert" or "userSess" ' 
    9801021                                      'keywords must be set') 
    9811022  
     
    10001041    def getAttCert(self, 
    10011042                   username=None, 
    1002                    userCert=None, 
     1043                   userX509Cert=None, 
    10031044                   sessID=None, 
    1004                    **credWalletKw): 
     1045                   **credentialWalletKw): 
    10051046        """For a given user, request Attribute Certificate from an Attribute  
    10061047        Authority given by service URI.  If sucessful, an attribute  
     
    10141055        @param username: username to key into their session 
    10151056 
    1016         @type userCert: string 
    1017         @param userCert: user's X.509 certificate to key into their session 
     1057        @type userX509Cert: string 
     1058        @param userX509Cert: user's X.509 certificate to key into their session 
    10181059         
    10191060        @type sessID: string 
    10201061        @param sessID: user's ID to key into their session 
    10211062         
    1022         @type credWalletKw: dict 
    1023         @param **credWalletKw: keywords to CredentialWallet.getAttCert 
     1063        @type credentialWalletKw: dict 
     1064        @param **credentialWalletKw: keywords to CredentialWallet.getAttCert 
    10241065        """ 
    10251066         
     
    10291070        # input credential 
    10301071        userSess = self._connect2UserSession(username=username, sessID=sessID,  
    1031                                              userCert=userCert) 
     1072                                             userX509Cert=userX509Cert) 
    10321073         
    10331074        # The user's Credential Wallet carries out attribute request to the 
    10341075        # Attribute Authority 
    10351076        try: 
    1036             attCert = userSess.credWallet.getAttCert(**credWalletKw) 
     1077            attCert=userSess.credentialWallet.getAttCert(**credentialWalletKw) 
    10371078            return attCert, None, [] 
    10381079             
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/configfileparsers/test_configfileparsers.py

    r4319 r4401  
    7070        print "properties ..." 
    7171        print prop 
    72         print "prop['test2INIPropertyFile']['attributeAuthority']['name']=%s"%\ 
    73             prop['test2INIPropertyFile']['attributeAuthority']['name'] 
     72        print("prop['test2INIPropertyFile']['name']=%s"% 
     73                                        prop['test2INIPropertyFile']['name']) 
    7474             
    75         print("prop['test2INIPropertyFile']['attributeAuthority']['useSSL']" 
    76               "=%s" % prop['test2INIPropertyFile']['attributeAuthority'] 
    77               ['useSSL']) 
    78         print("prop['test2INIPropertyFile']['attributeAuthority']" 
    79               "['attCertLifetime']=%s" % prop['test2INIPropertyFile'] 
    80               ['attributeAuthority']['attCertLifetime']) 
     75        print("prop['test2INIPropertyFile']['useSSL']" 
     76              "=%s" % prop['test2INIPropertyFile']['useSSL']) 
     77        print("prop['test2INIPropertyFile']['attCertLifetime']=%s" %  
     78              prop['test2INIPropertyFile']['attCertLifetime']) 
    8179         
    82         assert(isinstance(prop['test2INIPropertyFile']['attributeAuthority'] 
    83                           ['attCertLifetime'], float)) 
     80        assert(isinstance(prop['test2INIPropertyFile']['attCertLifetime'],  
     81                          float)) 
    8482         
    85         assert(isinstance(prop['test2INIPropertyFile']['attributeAuthority'] 
    86                           ['useSSL'], bool)) 
     83        assert(isinstance(prop['test2INIPropertyFile']['useSSL'], bool)) 
    8784             
    8885    def test3ReadAndValidateProperties(self): 
     
    110107        assert(prop.keys()==['test3ReadAndValidateProperties']) 
    111108         
    112         assert(prop['test3ReadAndValidateProperties']['sessionManager'] 
    113                ['sslCertFile']) 
    114         assert('credentialWallet' in prop['test3ReadAndValidateProperties'] 
    115                ['sessionManager']) 
     109        assert(prop['test3ReadAndValidateProperties']['sslCertFile']) 
     110        assert('credentialWallet' in prop['test3ReadAndValidateProperties']) 
    116111         
    117112        # attributeAuthorityURI is not present in the config so it should be  
    118113        # set to its default value 
    119         assert(prop['test3ReadAndValidateProperties']['sessionManager'] 
     114        assert(prop['test3ReadAndValidateProperties'] 
    120115            ['credentialWallet']['attributeAuthorityURI']=='A DEFAULT VALUE') 
    121116         
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/credentialwallet/credWallet.cfg

    r4397 r4401  
    4141# digital signature of SOAP messages to Attribute Authorities 
    4242#wssCfgSection=WS-Security 
     43 
     44# ... or put the settings in the same section but prefix them with this prefix 
    4345wssCfgPrefix=wssecurity 
    4446 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionmanager/sessionMgr.cfg

    r4397 r4401  
    4343credentialWallet.sslCACertFilePathList=$NDGSEC_SM_UNITTEST_DIR/ca/ndg-test-ca.crt 
    4444 
    45 # Omit Credential Repository and use default NullCredentialRepository.  This 
    46 # setting is expected to tie up with the Session Manager's Credential 
    47 # Repository settings - see elsewhere in this file 
    48 #credentialWallet.credentialRepository= 
    49  
    5045# Allow Get Attribute Certificate calls to try to get a mapped certificate 
    5146# from another organisation trusted by the target Attribute Authority 
     
    6358# ...A section name could also be used. 
    6459#credentialWallet.wssCfgSection= 
     60 
     61# SOAP Signature Handler settings for the Credential Wallet's Attribute  
     62# Authority interface 
     63# 
     64# CA Certificates used to verify X.509 certs used in Attribute Certificates. 
     65# The CA certificates of other NDG trusted sites should go here.  NB, multiple 
     66# values should be delimited by a space 
     67credentialWallet.wssecurity.caCertFilePathList: $NDGSEC_SM_UNITTEST_DIR/ca/ndg-test-ca.crt 
     68 
     69# Signature of an outbound message 
     70# 
     71# Certificate associated with private key used to sign a message.  The sign  
     72# method will add this to the BinarySecurityToken element of the WSSE header.   
     73# binSecTokValType attribute must be set to 'X509' or 'X509v3' ValueType.   
     74# As an alternative, use signingCertChain - see below... 
     75 
     76# PEM encoded cert 
     77credentialWallet.wssecurity.signingCertFilePath: $NDGSEC_SM_UNITTEST_DIR/sm.crt 
     78 
     79# ... or provide file path to PEM encoded private key file 
     80credentialWallet.wssecurity.signingPriKeyFilePath: $NDGSEC_SM_UNITTEST_DIR/sm.key 
     81 
     82# Set the ValueType for the BinarySecurityToken added to the WSSE header for a 
     83# signed message.  See __setReqBinSecTokValType method and binSecTokValType  
     84# class variable for options - it may be one of X509, X509v3, X509PKIPathv1 or  
     85# give full namespace to alternative - see  
     86# ZSI.wstools.Namespaces.OASIS.X509TOKEN 
     87# 
     88# binSecTokValType determines whether signingCert or signingCertChain  
     89# attributes will be used. 
     90credentialWallet.wssecurity.reqBinSecTokValType: X509v3 
     91 
     92# Add a timestamp element to an outbound message 
     93credentialWallet.wssecurity.addTimestamp: True 
     94 
     95# For WSSE 1.1 - service returns signature confirmation containing signature  
     96# value sent by client 
     97credentialWallet.wssecurity.applySignatureConfirmation: True 
    6598 
    6699# Settings for Credential Repository plugin 
     
    90123authNService.basicAuthN.accounts: testuser:776767df1f96e3b773eceffad55c61eae53ea31fef3563732046a7a6 ndg-user:d63dc919e201d7bc4c825630d2cf25fdc93d4b2f0d46706d29038d01 
    91124 
    92 # 
    93 # SOAP Signature Handler settings for the Credential Wallet's Attribute  
    94 # Authority interface 
    95 # 
    96 # OUTBOUND MESSAGE CONFIG 
    97125 
    98 # CA Certificates used to verify X.509 certs used in Attribute Certificates. 
    99 # The CA certificates of other NDG trusted sites should go here.  NB, multiple 
    100 # values should be delimited by a space 
    101 wssecurity.caCertFilePathList: $NDGSEC_SM_UNITTEST_DIR/ca/ndg-test-ca.crt 
    102  
    103 # Signature of an outbound message 
    104  
    105 # Certificate associated with private key used to sign a message.  The sign  
    106 # method will add this to the BinarySecurityToken element of the WSSE header.   
    107 # binSecTokValType attribute must be set to 'X509' or 'X509v3' ValueType.   
    108 # As an alternative, use signingCertChain - see below... 
    109  
    110 # PEM encoded cert 
    111 wssecurity.signingCertFilePath: $NDGSEC_SM_UNITTEST_DIR/sm.crt 
    112  
    113 # ... or provide file path to PEM encoded private key file 
    114 wssecurity.signingPriKeyFilePath: $NDGSEC_SM_UNITTEST_DIR/sm.key 
    115  
    116 # Password protecting private key.  Leave blank if there is no password. 
    117 wssecurity.signingPriKeyPwd= 
    118  
    119 # Set the ValueType for the BinarySecurityToken added to the WSSE header for a 
    120 # signed message.  See __setReqBinSecTokValType method and binSecTokValType  
    121 # class variable for options - it may be one of X509, X509v3, X509PKIPathv1 or  
    122 # give full namespace to alternative - see  
    123 # ZSI.wstools.Namespaces.OASIS.X509TOKEN 
    124 # 
    125 # binSecTokValType determines whether signingCert or signingCertChain  
    126 # attributes will be used. 
    127 wssecurity.reqBinSecTokValType: X509v3 
    128  
    129 # Add a timestamp element to an outbound message 
    130 wssecurity.addTimestamp: True 
    131  
    132 # For WSSE 1.1 - service returns signature confirmation containing signature  
    133 # value sent by client 
    134 wssecurity.applySignatureConfirmation: True 
    135  
    136 # Inclusive namespace prefixes - for Exclusive Canonicalisation only 
    137 # TODO: include option to set C14N algorithm - C14N currently set to Exclusive 
    138  
    139 # Inclusive namespace prefixes Canonicalisation of reference elements -  
    140 # space separated list e.g. refC14nInclNS=wsse ds ns1 
    141 wssecurity.refC14nInclNS: 
    142  
    143 # Inclusive namespaces prefixes for Canonicalisation of SignedInfo element - 
    144 # same format as the above 
    145 wssecurity.signedInfoC14nInclNS: 
    146  
    147 # 
    148 # INBOUND MESSAGE CONFIG 
    149  
    150 # X.509 certificate used by verify method to verify a message.  This argument  
    151 # can be omitted if the message to be verified contains the X.509 certificate  
    152 # in the BinarySecurityToken element.  In this case, the cert read from the 
    153 # message will be assigned to the verifyingCert attribute. 
    154  
    155 # ... or provide file path PEM encode cert here 
    156 wssecurity.verifyingCertFilePath:  
    157  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionmanager/sessionMgrTest.cfg

    r4318 r4401  
    99# 
    1010# $Id:$ 
     11[DEFAULT] 
     12# For connect calls used to setup some of the unit tests 
     13username = testuser 
     14passphrase = testpassword 
     15userX509CertFilePath = $NDGSEC_SM_UNITTEST_DIR/user.crt 
     16userPriKeyFilePath = $NDGSEC_SM_UNITTEST_DIR/user.key 
     17userPriKeyPwd = testpassword 
     18 
    1119[setUp] 
    1220# Test with INI file - use of XML file likely to be deprecated 
     
    2129passphrase = testpassword 
    2230 
    23 [test2GetSessionStatus] 
     31[test2Connect2AuthNServiceReturningAUserCert] 
     32outputCredsFilePath = user.creds 
    2433 
    25 [test3ConnectNoCreateServerSess]          
     34[test4ConnectNoCreateServerSess]          
    2635username = testuser 
    2736passphrase = testpassword 
    2837 
    29 [test6GetAttCertWithSessID] 
     38[test7GetAttCertWithSessID] 
    3039aaURI = http://localhost:4900/AttributeAuthority 
    31 acOutFilePath = $NDGSEC_SM_UNITTEST_DIR/ac-out.xml 
     40acOutputFilePath = $NDGSEC_SM_UNITTEST_DIR/ac-out.xml 
    3241 
    3342[test6aGetAttCertRefusedWithSessID] 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionmanager/test_sessionmanager.py

    r4397 r4401  
    3434 
    3535class SessionManagerTestCase(unittest.TestCase): 
    36     """Unit test case for ndg.security.server.sessionmanager.SessionManager class. 
     36    """Unit test case for ndg.security.server.sessionmanager.SessionManager  
     37    class. 
    3738     
    3839    This class manages server side sessions""" 
    3940     
    40     test1Passphrase = None 
    41     test3Passphrase = None 
     41    passphrase = None 
     42    test4Passphrase = None 
    4243     
    4344    def setUp(self): 
     
    6162        self.sm = SessionManager(propFilePath=self.propFilePath) 
    6263 
    63     def _sessionMgrConnect(self): 
     64    def _connect(self): 
    6465        '''Helper method to set up connections''' 
    6566        print "Connecting to session manager..." 
     67        section = 'DEFAULT' 
     68         
     69        username = self.cfg.get(section, 'username') 
     70        if SessionManagerTestCase.passphrase is None and \ 
     71           self.cfg.has_option(section, 'passphrase'): 
     72            SessionManagerTestCase.passphrase=self.cfg.get(section, 
     73                                                           'passphrase') 
     74         
     75        if not SessionManagerTestCase.passphrase: 
     76            SessionManagerTestCase.passphrase = getpass.getpass( 
     77                            prompt="\nPass-phrase for user %s: " % username) 
     78 
     79        print("Connecting to session manager as user: %s..." % username) 
     80        userX509Cert, userPriKey, issuingCert, self.sessID = \ 
     81            self.sm.connect(username=username,  
     82                            passphrase=SessionManagerTestCase.passphrase) 
     83 
     84        print("User '%s' connected to Session Manager:\n%s" % (username,  
     85                                                               self.sessID)) 
     86        print("Finished setting up connection") 
     87 
     88    def _connect2UserCertAuthNService(self): 
     89        '''Same as _connect but Session Manager is using an Authentication  
     90        Service that returns PKI credentials i.e. like MyProxy''' 
     91         
     92        section = 'DEFAULT' 
     93 
     94        print("Connecting to session manager with AuthN service returning " 
     95              "PKI creds...") 
     96                
     97        # Change to alternative authentication service 
     98        userX509CertFilePath = self.cfg.get(section, 'userX509CertFilePath') 
     99        userPriKeyFilePath = self.cfg.get(section, 'userPriKeyFilePath') 
     100        userPriKeyPwd = self.cfg.get(section, 'userPriKeyPwd') 
     101                                           
     102        self.sm['authNService'] = { 
     103            'moduleFilePath': os.environ['NDGSEC_SM_UNITTEST_DIR'], 
     104            'moduleName': 'usercertauthn', 
     105            'className': 'UserCertAuthN', 
     106            'userX509CertFilePath': userX509CertFilePath, 
     107            'userPriKeyFilePath': userPriKeyFilePath 
     108        } 
     109 
     110        self.sm.initAuthNService() 
     111         
     112        username = self.cfg.get(section, 'username') 
     113        if SessionManagerTestCase.passphrase is None and \ 
     114           self.cfg.has_option(section, 'passphrase'): 
     115            SessionManagerTestCase.passphrase=self.cfg.get(section,  
     116                                                           'passphrase') 
     117         
     118        if not SessionManagerTestCase.passphrase: 
     119            SessionManagerTestCase.passphrase = getpass.getpass(\ 
     120                prompt="\nPass-phrase for user %s: " % username) 
     121 
     122        print("Connecting to session manager as user: %s..." % username) 
     123        userX509Cert, self.userPriKey, self.issuingCert, self.sessID = \ 
     124            self.sm.connect(username=username,  
     125                            passphrase=SessionManagerTestCase.passphrase) 
     126        self.userX509Cert = X509CertParse(userX509Cert) 
     127         
     128        print("User '%s' connected to Session Manager:\n%s" % (username,  
     129                                                               self.sessID)) 
     130        print("Finished setting up connection") 
     131    
     132    def test1Connect2AuthNServiceWithNoUserCertReturned(self): 
     133         
    66134        username = self.cfg.get('test1Connect', 'username') 
    67         if SessionManagerTestCase.test1Passphrase is None and \ 
     135        if SessionManagerTestCase.passphrase is None and \ 
    68136           self.cfg.has_option('test1Connect', 'passphrase'): 
    69             SessionManagerTestCase.test1Passphrase=self.cfg.get('test1Connect',  
     137            SessionManagerTestCase.passphrase=self.cfg.get('test1Connect',  
    70138                                                                'passphrase') 
    71139         
    72         if not SessionManagerTestCase.test1Passphrase: 
    73             SessionManagerTestCase.test1Passphrase = getpass.getpass(\ 
     140        if not SessionManagerTestCase.passphrase: 
     141            SessionManagerTestCase.passphrase = getpass.getpass( 
    74142                prompt="\ntest1Connect pass-phrase for user %s: " % username) 
    75143 
    76         print "Connecting to session manager as user: %s..." % username 
    77         userCert, self.userPriKey, self.issuingCert, self.sessID = \ 
    78             self.sm.connect(username=username,  
    79                             passphrase=SessionManagerTestCase.test1Passphrase) 
    80 #        self.userCert = X509CertParse(userCert) 
    81 #         
    82         print "User '%s' connected to Session Manager:\n%s" % (username,  
    83                                                                self.sessID) 
    84 #        creds='\n'.join((self.issuingCert or '', 
    85 #                         self.userCert.asPEM().strip(), 
    86 #                         self.userPriKey)) 
    87 #        open(mkPath("user.creds"), "w").write(creds) 
    88         print "Finished setting up connection" 
    89          
    90                                    
    91     def test1Connect2AuthNServiceWithNoUserCertReturned(self): 
    92          
    93         username = self.cfg.get('test1Connect', 'username') 
    94         if SessionManagerTestCase.test1Passphrase is None and \ 
    95            self.cfg.has_option('test1Connect', 'passphrase'): 
    96             SessionManagerTestCase.test1Passphrase=self.cfg.get('test1Connect',  
    97                                                                 'passphrase') 
    98          
    99         if not SessionManagerTestCase.test1Passphrase: 
    100             SessionManagerTestCase.test1Passphrase = getpass.getpass( 
    101                 prompt="\ntest1Connect pass-phrase for user %s: " % username) 
    102  
    103144        print "Connecting to session manager as user: %s..." %username 
    104         userCert, userPriKey, issuingCert, sessID = self.sm.connect( 
    105                             username=username,  
    106                             passphrase=SessionManagerTestCase.test1Passphrase) 
    107         assert(userCert is None) 
     145        userX509Cert, userPriKey, issuingCert, sessID = self.sm.connect( 
     146                                username=username,  
     147                                passphrase=SessionManagerTestCase.passphrase) 
     148        assert(userX509Cert is None) 
    108149        assert(userPriKey is None) 
    109150        assert(issuingCert is None) 
     
    114155    def test2Connect2AuthNServiceReturningAUserCert(self): 
    115156         
    116         username = self.cfg.get('test1Connect', 'username') 
    117         if SessionManagerTestCase.test1Passphrase is None and \ 
    118            self.cfg.has_option('test1Connect', 'passphrase'): 
    119             SessionManagerTestCase.test1Passphrase=self.cfg.get('test1Connect',  
    120                                                                 'passphrase') 
    121          
    122         if not SessionManagerTestCase.test1Passphrase: 
    123             SessionManagerTestCase.test1Passphrase = getpass.getpass( 
    124                 prompt="\ntest1Connect pass-phrase for user %s: " % username) 
    125  
    126         print "Connecting to session manager as user: %s..." %username 
    127         userCert, self.userPriKey, self.issuingCert, sessID = \ 
    128             self.sm.connect(username=username,  
    129                             passphrase=SessionManagerTestCase.test1Passphrase) 
    130         self.userCert = X509CertParse(userCert) 
    131          
    132         print "User '%s' connected to Session Manager:\n%s" % \ 
    133                                                         (username, sessID) 
     157        section = 'test2Connect2AuthNServiceReturningAUserCert' 
     158         
     159        # Change to alternative authentication service 
     160        userX509CertFilePath = self.cfg.get('DEFAULT', 'userX509CertFilePath') 
     161        userPriKeyFilePath = self.cfg.get('DEFAULT', 'userPriKeyFilePath') 
     162        userPriKeyPwd = self.cfg.get('DEFAULT', 'userPriKeyPwd') 
     163        outputCredFilePath = self.cfg.get(section, 'outputCredsFilePath') 
     164                                           
     165        self.sm['authNService'] = { 
     166            'moduleFilePath': os.environ['NDGSEC_SM_UNITTEST_DIR'], 
     167            'moduleName': 'usercertauthn', 
     168            'className': 'UserCertAuthN', 
     169            'userX509CertFilePath': userX509CertFilePath, 
     170            'userPriKeyFilePath': userPriKeyFilePath 
     171        } 
     172 
     173        self.sm.initAuthNService() 
     174         
     175        print("Connecting to session manager...") 
     176        userX509Cert, self.userPriKey, self.issuingCert, sessID = self.sm.connect( 
     177                                                    passphrase=userPriKeyPwd) 
     178        self.userX509Cert = X509CertParse(userX509Cert) 
     179         
     180        print("Connected to Session Manager:\n%s" % sessID) 
    134181        creds='\n'.join((self.issuingCert or '', 
    135                          self.userCert.asPEM().strip(), 
     182                         self.userX509Cert.asPEM().strip(), 
    136183                         self.userPriKey)) 
    137         open(mkPath("user.creds"), "w").write(creds) 
    138      
    139              
    140     def test2GetSessionStatus(self): 
    141         """test2GetSessionStatus: check a session is alive""" 
    142          
    143         self._sessionMgrConnect() 
     184        open(mkPath(outputCredFilePath), "w").write(creds) 
     185     
     186             
     187    def test3GetSessionStatus(self): 
     188        """test3GetSessionStatus: check a session is alive""" 
     189         
     190        self._connect() 
    144191        assert self.sm.getSessionStatus(sessID=self.sessID), "Session is dead" 
    145192        print "User connected to Session Manager with sessID=%s" % self.sessID 
     
    150197        print "CORRECT: sessID=abc doesn't exist" 
    151198         
    152     def test3ConnectNoCreateServerSess(self): 
    153         """test3ConnectNoCreateServerSess: Connect as a non browser client -  
    154         sessID should be None""" 
    155         section = 'test3ConnectNoCreateServerSess' 
     199    def test4ConnectNoCreateServerSess(self): 
     200        """test4ConnectNoCreateServerSess: Connect to retrieve credentials 
     201        only - no session is created.  This makes sense only for an AuthN 
     202        Service that returns user credentials""" 
     203        section = 'test4ConnectNoCreateServerSess' 
     204         
     205        # Change to alternative authentication service 
     206        userX509CertFilePath = self.cfg.get('DEFAULT', 'userX509CertFilePath') 
     207        userPriKeyFilePath = self.cfg.get('DEFAULT', 'userPriKeyFilePath') 
     208        userPriKeyPwd = self.cfg.get('DEFAULT', 'userPriKeyPwd') 
     209                                           
     210        self.sm['authNService'] = { 
     211            'moduleFilePath': os.environ['NDGSEC_SM_UNITTEST_DIR'], 
     212            'moduleName': 'usercertauthn', 
     213            'className': 'UserCertAuthN', 
     214            'userX509CertFilePath': userX509CertFilePath, 
     215            'userPriKeyFilePath': userPriKeyFilePath 
     216        } 
     217 
     218        self.sm.initAuthNService() 
     219         
     220         
    156221        username = self.cfg.get(section, 'username') 
    157222 
    158         if SessionManagerTestCase.test3Passphrase is None and \ 
     223        if SessionManagerTestCase.test4Passphrase is None and \ 
    159224           self.cfg.has_option(section, 'passphrase'): 
    160             SessionManagerTestCase.test3Passphrase = self.cfg.get(section,  
     225            SessionManagerTestCase.test4Passphrase = self.cfg.get(section,  
    161226                                                                  'passphrase') 
    162227         
    163         if not SessionManagerTestCase.test3Passphrase: 
    164             SessionManagerTestCase.test3Passphrase = getpass.getpass(prompt=\ 
    165                                             "\ntest3ConnectNoCreateServerSess " 
    166                                             "pass-phrase for user %s: " %  
    167                                             username) 
    168  
    169         self.userCert, self.userPriKey, self.issuingCert, sessID = \ 
     228        if not SessionManagerTestCase.test4Passphrase: 
     229            SessionManagerTestCase.test4Passphrase = getpass.getpass(prompt=\ 
     230                                            "\n%s pass-phrase for user %s: " %  
     231                                            (section, username)) 
     232 
     233        userX509Cert, userPriKey, issuingCert, sessID = \ 
    170234            self.sm.connect(username=username,  
    171                             passphrase=SessionManagerTestCase.test3Passphrase, 
     235                            passphrase=SessionManagerTestCase.test4Passphrase, 
    172236                            createServerSess=False) 
    173237         
     
    176240           
    177241        print("User '%s' retrieved creds. from Session Manager:\n%s" %  
    178                                                     (username, self.userCert)) 
    179              
    180  
    181     def test4DisconnectWithSessID(self): 
    182         """test4DisconnectWithSessID: disconnect as if acting as a browser  
     242                                                    (username, sessID)) 
     243             
     244 
     245    def test5DisconnectWithSessID(self): 
     246        """test5DisconnectWithSessID: disconnect as if acting as a browser  
    183247        client  
    184248        """ 
    185249         
    186         self._sessionMgrConnect()         
     250        self._connect()         
    187251        self.sm.deleteUserSession(sessID=self.sessID) 
    188252         
     
    190254             
    191255 
    192     def test5DisconnectWithUserCert(self): 
    193         """test5DisconnectWithUserCert: Disconnect as a command line client  
     256    def test6DisconnectWithUserCert(self): 
     257        """test5DisconnectWithUserCert: Disconnect based on a user X.509 
     258        cert. credential from an earlier call to connect  
    194259        """ 
    195260         
    196         self._sessionMgrConnect() 
    197          
    198         # Proxy cert in signature determines ID of session to 
    199         # delete 
    200         self.sm.deleteUserSession(userCert=self.userCert) 
    201         print "User disconnected from Session Manager:\n%s" % self.userCert 
    202  
    203  
    204     def test6GetAttCertWithSessID(self): 
    205         """test6GetAttCertWithSessID: make an attribute request using 
     261        self._connect2UserCertAuthNService() 
     262         
     263        # User cert DN determines ID of session to delete 
     264        self.sm.deleteUserSession(userX509Cert=self.userX509Cert) 
     265        print "User disconnected from Session Manager:\n%s" % self.userX509Cert 
     266 
     267 
     268    def test7GetAttCertWithSessID(self): 
     269        """test7GetAttCertWithSessID: make an attribute request using 
    206270        a session ID as authentication credential""" 
    207271 
    208         self._sessionMgrConnect() 
    209          
    210         section = 'test6GetAttCertWithSessID' 
    211         attCert, errMsg, extAttCertList = self.sm.getAttCert(\ 
    212                                         sessID=self.sessID,  
    213                                         aaURI=self.cfg.get(section, 'aaURI')) 
     272        self._connect() 
     273         
     274        section = 'test7GetAttCertWithSessID' 
     275        aaURI = self.cfg.get(section, 'aaURI') 
     276        attCert, errMsg, extAttCertList=self.sm.getAttCert(sessID=self.sessID,  
     277                                                           aaURI=aaURI) 
    214278        if errMsg: 
    215279            self.fail(errMsg) 
    216280             
    217281        print "Attribute Certificate:\n%s" % attCert  
    218         attCert.filePath = xpdVars(self.cfg.get(section, 'acoutfilepath'))  
     282        attCert.filePath = xpdVars(self.cfg.get(section, 'acOutputFilePath'))  
    219283        attCert.write() 
    220284         
     
    222286 
    223287 
    224     def test6aGetAttCertRefusedWithSessID(self): 
     288    def test8GetAttCertRefusedWithSessID(self): 
    225289        """test6aGetAttCertRefusedWithSessID: make an attribute request using 
    226290        a sessID as authentication credential requesting an AC from an 
    227291        Attribute Authority where the user is NOT registered""" 
    228292 
    229         self._sessionMgrConnect() 
     293        self._connect() 
    230294         
    231295        aaURI = self.cfg.get('test6aGetAttCertRefusedWithSessID', 'aaURI') 
     
    241305 
    242306 
    243     def test6bGetMappedAttCertWithSessID(self): 
     307    def test9GetMappedAttCertWithSessID(self): 
    244308        """test6bGetMappedAttCertWithSessID: make an attribute request using 
    245309        a session ID as authentication credential""" 
    246310 
    247         self._sessionMgrConnect() 
     311        self._connect() 
    248312         
    249313        # Attribute Certificate cached in test 6 can be used to get a mapped 
    250314        # AC for this test ... 
    251         self.sm = self.test6GetAttCertWithSessID() 
     315        self.sm = self.test7GetAttCertWithSessID() 
    252316 
    253317        aaURI = self.cfg.get('test6bGetMappedAttCertWithSessID', 'aaURI') 
     
    266330        a session ID as authentication credential""" 
    267331         
    268         self._sessionMgrConnect() 
     332        self._connect() 
    269333        section = 'test6cGetAttCertWithExtAttCertListWithSessID' 
    270334        aaURI = self.cfg.get(section, 'aaURI') 
     
    287351        """test7GetAttCertWithUserCert: make an attribute request using 
    288352        a user cert as authentication credential""" 
    289         self._sessionMgrConnect() 
     353        self._connect() 
    290354 
    291355        # Request an attribute certificate from an Attribute Authority  
    292         # using the userCert returned from connect() 
     356        # using the userX509Cert returned from connect() 
    293357         
    294358        aaURI = self.cfg.get('test7GetAttCertWithUserCert', 'aaURI') 
    295359        attCert, errMsg, extAttCertList = self.sm.getAttCert( 
    296                                      userCert=self.userCert, aaURI=aaURI) 
     360                                     userX509Cert=self.userX509Cert, aaURI=aaURI) 
    297361        if errMsg: 
    298362            self.fail(errMsg) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionmanager/usercertauthn.py

    r4397 r4401  
    2222 
    2323class UserCertAuthN(AbstractAuthNService): 
    24     '''Provide a basic Authentication interface to the Session Manager  
    25     based on username/password entries in a config file''' 
     24    '''Test Authentication interface to the Session Manager  
     25    returning a certificate and private key 
     26     
     27    For use with SessionManager unittests only''' 
    2628     
    2729    def __init__(self, **prop): 
    28         '''Instantiate MyProxy client object taking in settings from the  
    29         properties file''' 
    30         accounts = prop.get('basicAuthN_accounts', []).split() 
    31         self.accounts = dict([tuple(account.split(':')) \ 
    32                               for account in accounts]) 
    33         
     30        '''Instantiate client object from X.509 cert and private key file path 
     31        inputs.  Private key must be none password protected.''' 
     32        self.userX509Cert = open(prop['userX509CertFilePath']).read() 
     33        self.userPriKey = open(prop['userPriKeyFilePath']).read() 
     34         
    3435    def logon(self, username, passphrase): 
    35         '''Implementation of AbstractAuthNService logon for a MyProxy client 
     36        '''Implementation of AbstractAuthNService logon for Session Manager 
     37        unittests.  TEST ONLY - no check is carried out on username/passphrase 
     38        credentials 
     39         
    3640        @type username: basestring 
    3741        @param username: username for account login 
    3842        @type passphrase: basestring 
    3943        @param passphrase: passphrase (or password) for user account 
    40         @rtype: None 
    41         @return: this interface doesn't return any user PKI credentials. 
     44        @rtype: tuple 
     45        @return: user PKI credentials. 
    4246        ''' 
    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)) 
    49  
    50         if self.accounts.get(username) != md5Passwd: 
    51             raise AuthNServiceInvalidCredentials() 
     47         
     48        return self.userX509Cert, self.userPriKey 
Note: See TracChangeset for help on using the changeset viewer.