Changeset 2620


Ignore:
Timestamp:
20/06/07 10:14:00 (12 years ago)
Author:
pjkersha
Message:

ndg.security.server/ndg/security/server/SessionMgr/server-config.tac:

  • added X509CertRead import
  • removed getCookie keyword from connect call - no longer needed
  • changed connect response to return sessID instead of cookie
  • soap_disconnect - pick up userCert arg if message wasn't signed
  • soap_getAttCert - remove refs to encrSessMgrURI - no longer needed

ndg.security.server/ndg/security/server/SessionMgr/init.py:

  • include X509Cert import
  • SessionMgr?.connect: removed getCookie keyword no longer needed. Put in

explicit keyword args rather than kw; return sessID instead of cookie

  • SessionMgr?.connect2UserSession: allow X509Cert type input for cert.

www/html/sessionMgr.wsdl,
ndg.security.server/ndg/security/server/SessionMgr/SessionMgr_services_server.py,
ndg.security.common/ndg/security/common/SessionMgr/SessionMgr_services.py,
ndg.security.common/ndg/security/common/SessionMgr/SessionMgr_services_types.py:

  • get rid of getCookie input to connect
  • change sessCookie to sessID in connect response
  • get rid of encrSessMgrURI inputs

ndg.security.test/ndg/security/test/SessionMgr/SessionMgrClientTest.py:

  • swapped sessCookie for sessID vars
  • commented out test1AddUser - this method is likely to go from Session

Manager

  • test2CookieConnect and test3ProxyCertConnect replaced with test2Connect

as SessionMgr?.connect effectively behaces the same in both cases, a proxy
cert and sess id are returned.

  • test3ConnectNoCreateServerSess: new test returns proxy cert from Session

Manager but doesn't create a session - effectively MyProxy? get delegation over
SOAP

  • test4CookieDisconnect -> test4DisconnectUsingSessID because sess id is used

instead of cookies for SM interface

  • test5ProxyCertDisconnect -> test5DisconnectUsingProxyCert - more clear

naming

  • likewise, test6CookieGetAttCert -> test6GetAttCertUsingSessID ... and

other test method names ...

  • test7ProxyCertGetAttCert: important change - use proxy cert returned from

test2Connect in order to authenticate in this request

ndg.security.test/ndg/security/test/SessionMgr/sessionMgrClientTest.cfg:

  • updated test section names
  • use server cert settings for initial connection to SM. Once connect has

been called, client can use proxy cert.

ndg.security.test/ndg/security/test/SessionCookie/SessionCookieTest.py:
fixes for complete working version

ndg.security.common/ndg/security/common/SessionMgr/init.py:

  • remove getCookie keyword for connect method. connect now returns sessID

instead of complete cookie

  • remove encrSessionMgrURI and sessCookie keywords from disconnect and

getAttCert calls - no longer needed.

ndg.security.common/ndg/security/common/X509.py:

  • enable X509Stack.push to take a cert in string format as input.

ndg.security.common/ndg/security/common/SessionCookie.py:

  • include timedelta import - enables specification of lifetime from now

for cookie

  • fix signingPriKey -> priKey

ndg.security.common/ndg/security/common/wsSecurity.py: make Crypto import
conditional as users of SignatureHandler? only don't need it

Location:
TI12-security/trunk/python
Files:
13 edited

Legend:

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

    r2573 r2620  
    1515 
    1616import base64 
    17 from datetime import datetime 
     17from datetime import datetime, timedelta 
    1818from Cookie import SimpleCookie 
    1919from M2Crypto import X509, BIO, RSA 
     
    4444    def __getSessIDlen(cls): 
    4545        '''This sets the session ID length (!)''' 
    46         return 64 
     46        return 32 
    4747     
    4848    sessIDlen = property(fget=__getSessIDlen) 
     
    161161        if isinstance(signingPriKey, basestring): 
    162162            pwdCallback = lambda *ar, **kw: self.__priKeyPwd 
    163             self.__signingPriKey = RSA.load_key_string(signingPriKey, 
     163            self.__priKey = RSA.load_key_string(signingPriKey, 
    164164                                                       callback=pwdCallback) 
    165165 
    166166        elif isinstance(signingPriKey, RSA.RSA): 
    167             self.__signingPriKey = signingPriKey  
     167            self.__priKey = signingPriKey  
    168168                    
    169169        else: 
     
    185185                priKeyFile = BIO.File(open(priKeyFilePath))  
    186186                pwdCallback = lambda *ar, **kw: self.__priKeyPwd                                            
    187                 self.__signingPriKey = RSA.load_key_bio(priKeyFile,  
     187                self.__priKey = RSA.load_key_bio(priKeyFile,  
    188188                                                        callback=pwdCallback)            
    189189            except Exception, e: 
     
    232232        try: 
    233233            # Check for expected cookie morsel 
    234             morsel = simpleCookie[self.__class__.tag].value 
    235             decrMorsel = self.__priKey.decrypt(morsel) 
    236             morselArgs = self.morselArgSep.split(decrMorsel) 
     234            b64EncMorsel = self.__simpleCookie[self.__class__.tag].value 
     235            encrMorsel = base64.urlsafe_b64decode(b64EncMorsel) 
     236            morsel = self.__priKey.private_decrypt(encrMorsel,  
     237                                                       RSA.pkcs1_padding) 
     238            morselArgs = morsel.split(self.morselArgSep) 
    237239             
    238240        except KeyError: 
    239241            raise SessionCookieError, 'Missing cookie morsel "%s"' % \ 
    240242                                      SessionCookie.tag 
    241          
     243        import pdb;pdb.set_trace() 
    242244        if len(morselArgs) != self.__class__.nMorselArgs: 
    243245            raise SessionCookieError, \ 
     
    256258               dtExpiry=None, 
    257259               strExpiry=None, 
    258                lifetime=28800,): 
    259         '''Create an NDG Session cookie''' 
     260               lifetime=28800): 
     261        '''Create an NDG Session cookie.  Requires x509Cert to be set''' 
    260262        morselArgs = userDN, sessID, sessMgrURI 
    261263        self.__userDN, self.__sessID, self.__sessMgrURI = morselArgs 
    262264                         
    263265        morsel = self.__class__.morselArgSep.join(morselArgs) 
    264         encrMorsel = self.__priKey.encrypt(morsel) 
    265         b64EncMorsel = base64.encodestring(encrMorsel) 
     266  
     267        rsaPubKey = self.__x509Cert.pubKey.get_rsa() 
     268        encrMorsel = rsaPubKey.public_encrypt(morsel, RSA.pkcs1_padding) 
     269        b64EncMorsel = base64.urlsafe_b64encode(encrMorsel) 
    266270 
    267271 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgr/SessionMgr_services.py

    r2437 r2620  
    2929        # no ws-addressing 
    3030 
    31     # op: <ZSI.wstools.WSDLTools.Message instance at 0x406c062c> 
     31    # op: <ZSI.wstools.WSDLTools.Message instance at 0x406d74cc> 
    3232    def addUser(self, username,passphrase): 
    3333 
     
    4343        return  
    4444 
    45     # op: <ZSI.wstools.WSDLTools.Message instance at 0x406c092c> 
    46     def connect(self, username,passphrase,createServerSess,getCookie): 
     45    # op: <ZSI.wstools.WSDLTools.Message instance at 0x406d77cc> 
     46    def connect(self, username,passphrase,createServerSess): 
    4747 
    4848        request = connectInputMsg() 
     
    5050        request._passphrase = passphrase 
    5151        request._createServerSess = createServerSess 
    52         request._getCookie = getCookie 
    5352 
    5453        kw = {} 
     
    6059        proxyPriKey = response._proxyPriKey 
    6160        userCert = response._userCert 
    62         cookie = response._cookie 
    63         return proxyCert,proxyPriKey,userCert,cookie 
     61        sessID = response._sessID 
     62        return proxyCert,proxyPriKey,userCert,sessID 
    6463 
    65     # op: <ZSI.wstools.WSDLTools.Message instance at 0x406c762c> 
    66     def disconnect(self, sessID,encrSessionMgrURI): 
     64    # op: <ZSI.wstools.WSDLTools.Message instance at 0x406d544c> 
     65    def disconnect(self, userCert,sessID): 
    6766 
    6867        request = disconnectInputMsg() 
     68        request._userCert = userCert 
    6969        request._sessID = sessID 
    70         request._encrSessionMgrURI = encrSessionMgrURI 
    7170 
    7271        kw = {} 
     
    7776        return  
    7877 
    79     # op: <ZSI.wstools.WSDLTools.Message instance at 0x406c77cc> 
    80     def getAttCert(self, userCert,sessID,encrSessionMgrURI,attAuthorityURI,attAuthorityCert,reqRole,mapFromTrustedHosts,rtnExtAttCertList,extAttCert,extTrustedHost): 
     78    # op: <ZSI.wstools.WSDLTools.Message instance at 0x406d55ec> 
     79    def getAttCert(self, userCert,sessID,attAuthorityURI,attAuthorityCert,reqRole,mapFromTrustedHosts,rtnExtAttCertList,extAttCert,extTrustedHost): 
    8180 
    8281        request = getAttCertInputMsg() 
    8382        request._userCert = userCert 
    8483        request._sessID = sessID 
    85         request._encrSessionMgrURI = encrSessionMgrURI 
    8684        request._attAuthorityURI = attAuthorityURI 
    8785        request._attAuthorityCert = attAuthorityCert 
     
    102100        return attCert,msg,extAttCertOut 
    103101 
    104     # op: <ZSI.wstools.WSDLTools.Message instance at 0x406c794c> 
     102    # op: <ZSI.wstools.WSDLTools.Message instance at 0x406d576c> 
    105103    def getX509Cert(self): 
    106104 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgr/SessionMgr_services_types.py

    r2437 r2620  
    6363        def __init__(self, **kw): 
    6464            ns = ns0.connect_Dec.schema 
    65             TClist = [ZSI.TC.String(pname="username", aname="_username", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="passphrase", aname="_passphrase", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="createServerSess", aname="_createServerSess", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="getCookie", aname="_getCookie", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
     65            TClist = [ZSI.TC.String(pname="username", aname="_username", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="passphrase", aname="_passphrase", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="createServerSess", aname="_createServerSess", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
    6666            kw["pname"] = ("urn:ndg:security:sessionMgr","connect") 
    6767            kw["aname"] = "_connect" 
     
    7676                    self._passphrase = None 
    7777                    self._createServerSess = None 
    78                     self._getCookie = None 
    7978                    return 
    8079            Holder.__name__ = "connect_Holder" 
     
    8685        def __init__(self, **kw): 
    8786            ns = ns0.connectResponse_Dec.schema 
    88             TClist = [ZSI.TC.String(pname="proxyCert", aname="_proxyCert", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="proxyPriKey", aname="_proxyPriKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="userCert", aname="_userCert", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="cookie", aname="_cookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
     87            TClist = [ZSI.TC.String(pname="proxyCert", aname="_proxyCert", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="proxyPriKey", aname="_proxyPriKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="userCert", aname="_userCert", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="sessID", aname="_sessID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
    8988            kw["pname"] = ("urn:ndg:security:sessionMgr","connectResponse") 
    9089            kw["aname"] = "_connectResponse" 
     
    9998                    self._proxyPriKey = None 
    10099                    self._userCert = None 
    101                     self._cookie = None 
     100                    self._sessID = None 
    102101                    return 
    103102            Holder.__name__ = "connectResponse_Holder" 
     
    109108        def __init__(self, **kw): 
    110109            ns = ns0.disconnect_Dec.schema 
    111             TClist = [ZSI.TC.String(pname="sessID", aname="_sessID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="encrSessionMgrURI", aname="_encrSessionMgrURI", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
     110            TClist = [ZSI.TC.String(pname="userCert", aname="_userCert", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="sessID", aname="_sessID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] 
    112111            kw["pname"] = ("urn:ndg:security:sessionMgr","disconnect") 
    113112            kw["aname"] = "_disconnect" 
     
    119118                def __init__(self): 
    120119                    # pyclass 
     120                    self._userCert = None 
    121121                    self._sessID = None 
    122                     self._encrSessionMgrURI = None 
    123122                    return 
    124123            Holder.__name__ = "disconnect_Holder" 
     
    149148        def __init__(self, **kw): 
    150149            ns = ns0.getAttCert_Dec.schema 
    151             TClist = [ZSI.TC.String(pname="userCert", aname="_userCert", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="sessID", aname="_sessID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="encrSessionMgrURI", aname="_encrSessionMgrURI", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="attAuthorityURI", aname="_attAuthorityURI", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="attAuthorityCert", aname="_attAuthorityCert", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="reqRole", aname="_reqRole", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="mapFromTrustedHosts", aname="_mapFromTrustedHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="rtnExtAttCertList", aname="_rtnExtAttCertList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="extAttCert", aname="_extAttCert", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="extTrustedHost", aname="_extTrustedHost", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] 
     150            TClist = [ZSI.TC.String(pname="userCert", aname="_userCert", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="sessID", aname="_sessID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="attAuthorityURI", aname="_attAuthorityURI", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="attAuthorityCert", aname="_attAuthorityCert", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="reqRole", aname="_reqRole", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="mapFromTrustedHosts", aname="_mapFromTrustedHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname="rtnExtAttCertList", aname="_rtnExtAttCertList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="extAttCert", aname="_extAttCert", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="extTrustedHost", aname="_extTrustedHost", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] 
    152151            kw["pname"] = ("urn:ndg:security:sessionMgr","getAttCert") 
    153152            kw["aname"] = "_getAttCert" 
     
    161160                    self._userCert = None 
    162161                    self._sessID = None 
    163                     self._encrSessionMgrURI = None 
    164162                    self._attAuthorityURI = None 
    165163                    self._attAuthorityCert = None 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgr/__init__.py

    r2530 r2620  
    198198                passphrase=None, 
    199199                passphraseFilePath=None, 
    200                 getCookie=False, 
    201200                createServerSess=True): 
    202201        """Request a new user session from the Session Manager 
     
    212211        Use this as an alternative to passphrase keyword. 
    213212                                  
    214         @type getCookie: bool 
    215         @keyword getCookie: If set to True, return a cookie to be set in  
    216         a web browser client.   
    217                                   
    218213        @type createServerSess: bool 
    219214        @keyword createServerSess: If set to True, the SessionMgr will create 
    220         and manage a session for the user but note, this flag is ignored and  
    221         set to True if getCookie is set.  For command line case, where  
    222         getCookie is False, it's possible to choose to have a client or server 
    223         side session using this keyword. 
     215        and manage a session for the user.  For non-browser client case, it's  
     216        possible to choose to have a client or server side session using this  
     217        keyword.  If set to False sessID returned will be None 
    224218         
    225219        @rtype: tuple 
    226         @return proxy cert, proxy private key, user cert and cookie all as 
    227         strings but cookie will be None if the getCookie keyword is False""" 
     220        @return proxy cert, proxy private key, user cert and sessID all as 
     221        strings but sessID will be None if the createServerSess keyword is  
     222        False""" 
    228223     
    229224        if passphrase is None: 
     
    237232        # Make connection 
    238233        try:  
    239             userID = self.__srv.connect(username,  
    240                                         passphrase, 
    241                                         createServerSess, 
    242                                         getCookie) 
    243             return userID 
     234            res = self.__srv.connect(username, passphrase, createServerSess) 
     235 
     236            # Convert from unicode because unicode causes problems with 
     237            # M2Crypto private key load 
     238            return tuple([isinstance(i,unicode) and str(i) or i for i in res]) 
    244239                
    245240        except Exception, e: 
     
    249244         
    250245    #_________________________________________________________________________    
    251     def disconnect(self, 
    252                    sessCookie=None, 
    253                    sessID=None, 
    254                    encrSessionMgrURI=None): 
     246    def disconnect(self, userCert=None, sessID=None): 
    255247        """Delete an existing user session from the Session Manager 
    256248         
    257         disconnect([sessCookie=s]|[sessID=i, encrSessionMgrURI=e]) 
    258          
    259         @type sessCookie: ndg.security.common.SessionCookie or string                  
    260         @keyword sessCookie: session cookie returned from call to connect()  
    261         for a browser client.   
     249        disconnect([userCert=c]|[sessID=i]) 
     250         
     251        @type userCert: string                  
     252        @keyword userCert: user's certificate used to identifier which session 
     253        to disconnect.  This arg is not needed if the message is signed with 
     254        the user cert or if sessID is set.   
    262255                                
    263256        @type sessID: string 
    264         @keyword sessID: session ID.  Input this as well as encrSessionMgrURI  
    265         as an alternative to sessCookie in the case of a browser client. 
    266          
    267         @type encrSessionMgrURI: string 
    268         @keyword encrSessionMgrURI: encrypted Session Manager URI.""" 
    269  
    270         # Checking authentication details: either a proxy cert,  
    271         # session cookie, or session ID/encrypted Session Manager URI 
    272         # combination 
    273         if sessCookie: 
    274             if isinstance(sessCookie, basestring): 
    275                 try: 
    276                     sessCookie = SessionCookie(sessCookie) 
    277                 except Exception, e: 
    278                     raise SessionMgrClientError, \ 
    279                                     "Error parsing session cookie: " + str(e) 
    280  
    281             sessID = sessCookie.sessionID 
    282             encrSessionMgrURI = sessCookie.encrSessionMgrURI 
     257        @keyword sessID: session ID.  Input this as an alternative to userCert 
     258        This arg is not needed if the message is signed with the user cert or  
     259        if userCert keyword is.""" 
    283260 
    284261        # Make connection 
    285262        try:  
    286             self.__srv.disconnect(sessID, encrSessionMgrURI) 
     263            self.__srv.disconnect(userCert, sessID) 
    287264                
    288265        except Exception, e: 
     
    294271    def getAttCert(self, 
    295272                   proxyCert=None, 
    296                    sessCookie=None, 
    297273                   sessID=None, 
    298                    encrSessionMgrURI=None, 
    299274                   attAuthorityURI=None, 
    300275                   attAuthorityCert=None, 
     
    308283        user's credential wallet held by the session manager. 
    309284         
    310         getAttCert([sessCookie=s]|[sessID=i, encrSessionMgrURI=e]| 
    311                    [proxyCert=p][key=arg, ...]) 
     285        getAttCert([sessID=i]|[proxyCert=p][key=arg, ...]) 
    312286                    
    313287        proxyCert:             proxy certificate - use as ID instead of  
    314                                a cookie in the case of a command line client. 
    315         sessCookie:            session cookie returned from call to connect()  
    316                                for a browser client.  Input as a string or 
    317                                SimpleCookie type. 
    318         sessID:                session ID.  Input this as well as  
    319                                encrSessionMgrURI as an alternative to  
    320                                sessCookie in the case of a browser client. 
    321         encrSessionMgrURI:     encrypted Session Manager URI. 
     288                               session ID.  This can be omitted if the  
     289                               message is signed with a proxy certificate. 
     290                               In this case the proxy certificate is passed 
     291                               in the BinarySecurityToken of the WS-Security 
     292                               header 
     293        sessID:                session ID.  Input this as an alternative to  
     294                               proxyCert in the case of a browser client. 
    322295        attAuthorityURI:       URI for Attribute Authority WS. 
    323296        attAuthorityCert:      The Session Manager uses the Public key of the 
     
    341314        """ 
    342315         
    343         # Checking authentication details: either a proxy cert,  
    344         # session cookie, or session ID/encrypted Session Manager URI 
    345         # combination 
    346         if sessCookie: 
    347             if isinstance(sessCookie, basestring): 
    348                 try: 
    349                     sessCookie = SessionCookie(sessCookie) 
    350                 except Exception, e: 
    351                     raise SessionMgrClientError, \ 
    352                                     "Error parsing session cookie: " + str(e) 
    353  
    354             sessID = sessCookie.sessionID 
    355             encrSessionMgrURI = sessCookie.encrSessionMgrURI 
    356              
    357         elif not sessID and not encrSessionMgrURI and not proxyCert: 
    358             raise SessionMgrClientError, \ 
    359                 '"proxyCert" or "sessCookie or "sessID" and ' + \ 
    360                 '"encrSessionMgrURI" keywords must be set' 
    361  
    362              
    363316        # Make request 
    364317        try: 
    365318            attCert, msg, extAttCertList = self.__srv.getAttCert(proxyCert, 
    366319                                                       sessID,  
    367                                                        encrSessionMgrURI, 
    368320                                                       attAuthorityURI, 
    369321                                                       attAuthorityCert, 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/X509.py

    r2515 r2620  
    384384         
    385385        @param x509Cert: X509 object. 
    386         @type x509Cert: M2Crypto.X509.X509 or 
    387         ndg.security.common.X509.X509Cert 
     386        @type x509Cert: M2Crypto.X509.X509, 
     387        ndg.security.common.X509.X509Cert or basestring 
    388388        @return: The number of X509 objects currently on the stack. 
    389389        @rtype: int""" 
    390390        if isinstance(x509Cert, M2Crypto.X509.X509): 
    391391            return self.__m2X509Stack.push(x509Cert) 
     392         
    392393        elif isinstance(x509Cert, X509Cert): 
    393394            return self.__m2X509Stack.push(x509Cert.m2CryptoX509) 
     395         
     396        elif isinstance(x509Cert, basestring): 
     397            return self.__m2X509Stack.push(\ 
     398                                       X509CertParse(x509Cert).m2CryptoX509)             
    394399        else: 
    395             raise X509StackError, "Expecting M2Crypto.X509.X509 or " + \ 
    396                 "ndg.security.common.X509.X509Cert type" 
     400            raise X509StackError, "Expecting M2Crypto.X509.X509, " + \ 
     401                "ndg.security.common.X509.X509Cert or string type" 
    397402                 
    398403    def pop(self): 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/wsSecurity.py

    r2515 r2620  
    2222import base64 
    2323 
    24 # For shared key encryption 
    25 from Crypto.Cipher import AES, DES3 
     24# Conditional import as this is required for the encryption 
     25# handler 
     26try: 
     27    # For shared key encryption 
     28    from Crypto.Cipher import AES, DES3 
     29except: 
     30    pass 
     31 
    2632import os 
    2733 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/SessionMgr_services_server.py

    r2437 r2620  
    3535            <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"passphrase\" type=\"xsd:string\"/> 
    3636                    <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"createServerSess\" type=\"xsd:boolean\"/> 
    37                     <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"getCookie\" type=\"xsd:boolean\"/> 
    3837          </xsd:sequence> 
    3938        </xsd:complexType> 
     
    4645                    <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"proxyPriKey\" type=\"xsd:string\"/> 
    4746                    <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"userCert\" type=\"xsd:string\"/> 
    48                     <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"cookie\" type=\"xsd:string\"/> 
     47                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"sessID\" type=\"xsd:string\"/> 
    4948                  </xsd:sequence> 
    5049                </xsd:complexType> 
     
    5251 
    5352      <xsd:element name=\"disconnect\"> 
    54         <xsd:complexType> 
    55                   <xsd:sequence> 
    56                     <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"sessID\" type=\"xsd:string\"/> 
    57                     <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"encrSessionMgrURI\" type=\"xsd:string\"/> 
    58                   </xsd:sequence> 
    59                 </xsd:complexType> 
    60       </xsd:element> 
    61  
    62       <xsd:element name=\"disconnectResponse\"> 
    63         <xsd:complexType/> 
    64       </xsd:element> 
    65              
    66       <xsd:element name=\"getAttCert\"> 
    6753        <xsd:complexType> 
    6854                  <xsd:sequence> 
    6955                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"userCert\" type=\"xsd:string\"/> 
    7056                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"sessID\" type=\"xsd:string\"/> 
    71                     <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"encrSessionMgrURI\" type=\"xsd:string\"/> 
     57                  </xsd:sequence> 
     58                </xsd:complexType> 
     59      </xsd:element> 
     60 
     61      <xsd:element name=\"disconnectResponse\"> 
     62        <xsd:complexType/> 
     63      </xsd:element> 
     64             
     65      <xsd:element name=\"getAttCert\"> 
     66        <xsd:complexType> 
     67                  <xsd:sequence> 
     68                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"userCert\" type=\"xsd:string\"/> 
     69                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"sessID\" type=\"xsd:string\"/> 
    7270                    <xsd:element maxOccurs=\"1\" minOccurs=\"1\" name=\"attAuthorityURI\" type=\"xsd:string\"/> 
    7371                    <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"attAuthorityCert\" type=\"xsd:string\"/> 
     
    265263    def soap_connect(self, ps): 
    266264        self.request = ps.Parse(connectInputMsg.typecode) 
    267         parameters = (self.request._username, self.request._passphrase, self.request._createServerSess, self.request._getCookie) 
    268  
    269         # If we have an implementation object use it 
    270         if hasattr(self,'impl'): 
    271             parameters = self.impl.connect(parameters[0],parameters[1],parameters[2],parameters[3]) 
     265        parameters = (self.request._username, self.request._passphrase, self.request._createServerSess) 
     266 
     267        # If we have an implementation object use it 
     268        if hasattr(self,'impl'): 
     269            parameters = self.impl.connect(parameters[0],parameters[1],parameters[2]) 
    272270 
    273271        result = connectOutputMsg() 
     
    278276            result._proxyPriKey = parameters[1] 
    279277            result._userCert = parameters[2] 
    280             result._cookie = parameters[3] 
     278            result._sessID = parameters[3] 
    281279        return self.request, result 
    282280 
     
    286284    def soap_disconnect(self, ps): 
    287285        self.request = ps.Parse(disconnectInputMsg.typecode) 
    288         parameters = (self.request._sessID, self.request._encrSessionMgrURI) 
     286        parameters = (self.request._userCert, self.request._sessID) 
    289287 
    290288        # If we have an implementation object use it 
     
    300298    def soap_getAttCert(self, ps): 
    301299        self.request = ps.Parse(getAttCertInputMsg.typecode) 
    302         parameters = (self.request._userCert, self.request._sessID, self.request._encrSessionMgrURI, self.request._attAuthorityURI, self.request._attAuthorityCert, self.request._reqRole, self.request._mapFromTrustedHosts, self.request._rtnExtAttCertList, self.request._extAttCert, self.request._extTrustedHost) 
    303  
    304         # If we have an implementation object use it 
    305         if hasattr(self,'impl'): 
    306             parameters = self.impl.getAttCert(parameters[0],parameters[1],parameters[2],parameters[3],parameters[4],parameters[5],parameters[6],parameters[7],parameters[8],parameters[9]) 
     300        parameters = (self.request._userCert, self.request._sessID, self.request._attAuthorityURI, self.request._attAuthorityCert, self.request._reqRole, self.request._mapFromTrustedHosts, self.request._rtnExtAttCertList, self.request._extAttCert, self.request._extTrustedHost) 
     301 
     302        # If we have an implementation object use it 
     303        if hasattr(self,'impl'): 
     304            parameters = self.impl.getAttCert(parameters[0],parameters[1],parameters[2],parameters[3],parameters[4],parameters[5],parameters[6],parameters[7],parameters[8]) 
    307305 
    308306        result = getAttCertOutputMsg() 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/__init__.py

    r2530 r2620  
    3939    CredWalletAttributeRequestDenied 
    4040 
    41 from ndg.security.common.X509 import X509CertParse 
     41from ndg.security.common.X509 import X509Cert, X509CertParse 
    4242 
    4343# MyProxy server interface 
     
    702702     
    703703    #_________________________________________________________________________         
    704     def connect(self, getCookie=False, createServerSess=True, **kw):         
     704    def connect(self,  
     705                createServerSess=True, 
     706                username=None, 
     707                passphrase=None,  
     708                proxyCert=None,  
     709                sessID=None):         
    705710        """Create a new user session or connect to an existing one: 
    706711 
    707         connect([getCookie=True/False][createServerSess=True/False, ] 
    708                 [, username=u, passphrase=p]|[, proxyCert=px]|[, sessID=id]) 
    709  
    710         @param getCookie: If True, allocate a user session with a wallet in  
    711         the session manager and return a cookie containing the new session ID  
    712         allocated.  If set False, return a proxy certificate only.  The client 
    713         is then responsible for Credential Wallet management. 
    714          
    715         @param createServerSess: If set to True, the SessionMgr will create 
    716         and manage a session for the user.  Nb. this flag is ignored and set  
    717         to True if getCookie is set.  For command line case, where getCookie 
    718         is False, it's possible to choose to have a client or server side 
    719         session using this keyword. 
    720          
    721         @param **kw: username and pass-phrase OR proxy certificate OR session  
    722         ID keywords 
     712        connect([createServerSess=True/False, ]|[, username=u, passphrase=p]| 
     713                [, proxyCert=px]|[, sessID=id]) 
     714 
     715        @type createUserSess: bool 
     716        @keyword createServerSess: If set to True, the SessionMgr will create 
     717        and manage a session for the user.  For command line case, it's  
     718        possible to choose to have a client or server side session using this  
     719        keyword. 
     720         
     721        @type username: string 
     722        @keyword username: username of account to connect to 
     723 
     724        @type passphrase: string 
     725        @keyword passphrase: pass-phrase - user with username arg 
     726         
     727        @type proxyCert: string 
     728        @keyword proxyCert: connect to existing session with proxy certificate 
     729        corresponding to user.  username/pass-phrase not required 
     730         
     731        @type sessID: string 
     732        @keyword sessID: connect to existing session corresponding to this ID. 
     733        username/pass-phrase not required. 
    723734         
    724735        @rtype: tuple 
    725736        @return proxy certificate, proxy private key, user certificate and  
    726         session cookie respectively.  Cookie will be None if getCookie is set  
    727         to False. Proxy cert. will be None if 'proxyCert' was set as an input. 
     737        session ID respectively.  Proxy cert. will be None if 'proxyCert' was  
     738        set as an input.  Session ID will be none if createUserSess keyword is 
     739        set to False 
    728740        """ 
    729741         
    730         # Initial proxy cert and cookie to be returned 
    731         proxyCert, sessCookie = None, None 
    732          
    733         if 'sessID' in kw:             
     742        # Initialise proxy cert to be returned 
     743        proxyCert = None 
     744         
     745        if sessID is not None:             
    734746            # Connect to an existing session identified by a session ID and  
    735747            # return equivalent proxy cert 
    736             userSess = self.__connect2UserSession(sessID=kw['sessID']) 
     748            userSess = self.__connect2UserSession(sessID=sessID) 
    737749            proxyCert = userSess.credWallet.proxyCertTxt 
    738750         
    739         elif 'proxyCert' in kw: 
     751        elif proxyCert is not None: 
    740752            # Connect to an existing session identified by a proxy  
    741753            # certificate  
    742             userSess = self.__connect2UserSession(proxyCert=kw['proxyCert']) 
    743              
    744             # Make a new session cookie 
    745             sessCookie = userSess.createCookie(\ 
    746                                    self.__prop['sessMgrURI'], 
    747                                    self.__prop['sessMgrEncrKey'], 
    748                                    cookieDomain=self.__prop['cookieDomain']) 
     754            userSess = self.__connect2UserSession(proxyCert=proxyCert) 
     755            sessID = userSess.latestSessID 
    749756        else: 
    750757            # Create a fresh session 
     
    752759                # Get a proxy certificate to represent users ID for the new 
    753760                # session 
    754                 proxyCert, proxyPriKey, userCert = \ 
    755                         self.__myPx.logon(kw['username'], kw['passphrase'])     
     761                proxyCert, proxyPriKey, userCert = self.__myPx.logon(username, 
     762                                                                   passphrase)     
    756763            except Exception, e: 
    757764                raise SessionMgrError, "Delegating from MyProxy: %s" % e 
    758765 
    759             if getCookie or createServerSess: 
     766            if createServerSess: 
    760767                # Session Manager creates and manages user's session 
    761768                userSess = self.__createUserSession(proxyCert,  
    762769                                                    proxyPriKey,  
    763770                                                    userCert) 
     771                sessID = userSess.latestSessID 
     772            else: 
     773                sessID = None 
    764774                                 
    765             if getCookie:                 
    766                 # Web browser client - Return session cookie 
    767                 sessCookie = userSess.createCookie(\ 
    768                                     self.__prop['sessMgrURI'], 
    769                                     self.__prop['sessMgrEncrKey'], 
    770                                     cookieDomain=self.__prop['cookieDomain']) 
    771                  
    772775        # Return proxy details and cookie 
    773         return proxyCert, proxyPriKey, userCert, sessCookie         
     776        return proxyCert, proxyPriKey, userCert, sessID         
    774777         
    775778        
     
    799802            # Different session IDs are allocated in each case. 
    800803            userSess = self.__dnDict[userDN] 
    801             userSess.addNewSessID() 
    802              
     804            userSess.addNewSessID()             
    803805        else: 
    804806            # Create a new user session using the new proxy certificate 
     
    857859                # User session not found with given ID 
    858860                raise SessionMgrError, \ 
    859                         "No user session found matching input session ID"         
    860         elif userCert: 
     861                        "No user session found matching input session ID" 
     862                                
     863        elif isinstance(userCert, basestring): 
    861864            try: 
    862865                userDN = str(X509CertParse(userCert).dn) 
     
    865868                raise SessionMgrError, \ 
    866869                "Parsing input user certificate DN for session connect: %s" %e 
     870 
    867871            try: 
    868872                userSess = self.__dnDict[userDN] 
     
    872876                raise SessionMgrError, \ 
    873877                    "No user session found matching input proxy certificate" 
     878                     
     879        elif isinstance(userCert, X509Cert): 
     880            try: 
     881                userDN = str(userCert.dn) 
     882                 
     883            except Exception, e: 
     884                raise SessionMgrError, \ 
     885                "Parsing input user certificate DN for session connect: %s" %e 
     886             
     887            try: 
     888                userSess = self.__dnDict[userDN] 
     889                         
     890            except KeyError: 
     891                # User session not found with given proxy cert 
     892                raise SessionMgrError, \ 
     893                    "No user session found matching input proxy certificate"             
    874894        else: 
    875895            raise SessionMgrError,\ 
     
    909929        @keyword userSess: user session object to be deleted 
    910930        """ 
    911          
    912              
     931          
    913932        # Look for a session corresponding to the session ID/proxy cert. 
    914933        if sessID: 
     
    972991        returned from this method 
    973992 
    974         @param **kw: keyword to CredWallet.getAttCert 
     993        @type userCert: string 
     994        @keyword userCert: user's certificate to key into their session 
     995         
     996        @type sessID: string 
     997        @keyword sessID: user's ID to key into their session 
     998         
     999        @type encrSessMgrURI: string 
     1000        @keyword encrSessMgrURI: URI for remote session manager to forward a 
     1001        request to.  This effectively use THIS session manager as a proxy to 
     1002        another.  This URI is encrypted with a shared key.  The key is stored 
     1003        in the property file 'sessMgrEncrKey' element.  *** This functionality 
     1004        is redundant for NDG BETA delivery *** 
     1005         
     1006        @type credWalletKw: dict 
     1007        @param **credWalletKw: keywords to CredWallet.getAttCert 
    9751008        """ 
    9761009         
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/server-config.tac

    r2530 r2620  
    2525from ndg.security.common.wsSecurity import WSSecurityHandlerChainFactory, \ 
    2626        WSSecurityHandler, SignatureHandler 
     27from ndg.security.common.X509 import X509CertRead 
    2728 
    2829 
     
    6667 
    6768        request, response = SessionMgrService.soap_connect(self, ps) 
    68  
     69         
    6970        result = self.sm.connect(username=request.Username, 
    7071                                                                 passphrase=request.Passphrase, 
    71                                                                  createServerSess=request.CreateServerSess, 
    72                                                                  getCookie=request.GetCookie) 
     72                                                                 createServerSess=request.CreateServerSess) 
    7373                                         
    7474        response.ProxyCert, response.ProxyPriKey, response.UserCert, \ 
    75                 response.Cookie = result 
     75                response.SessID = result 
    7676                          
    7777        return request, response 
     
    9090        # Derive designated user ID differently according to whether 
    9191        # a session ID was passed and the message was signed 
    92         if request.SessID: 
    93                 sessID = request.SessID 
    94         else: 
    95                 sessID = None 
     92        sessID = request.SessID or None 
    9693                 
    9794        if srv.sm['useSignatureHandler']: 
     
    10097            userCert = WSSecurityHandler.signatureHandler.verifyingCert 
    10198        else: 
    102             userCert = None 
     99            userCert = request.UserCert 
    103100 
    104101        self.sm.deleteUserSession(sessID=sessID, proxyCert=userCert) 
     
    116113 
    117114        request, response = SessionMgrService.soap_getAttCert(self, ps) 
    118          
     115 
    119116        # Get certificate corresponding to private key that signed the 
    120117        # message - i.e. the user's              
     
    131128                                            userCert=userCert or request.UserCert, 
    132129                                                sessID=request.SessID, 
    133                                                 encrSessMgrURI=request.EncrSessionMgrURI, 
    134130                                                aaURI=request.AttAuthorityURI, 
    135131                                                reqRole=request.ReqRole, 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionCookie/SessionCookieTest.py

    r2573 r2620  
    4040                    self.__class__.priKeyPwd = getpass.getpass(\ 
    4141                                prompt="\nsetUp - private key password: ") 
    42                     import pdb;pdb.set_trace() 
    4342                except KeyboardInterrupt: 
    4443                    raise SystemExit 
    4544         
    46         self.cookie.priKeyPwd = self.__class__.priKeyPwd 
     45        self.priKeyFilePath = configParser.get('setUp', 'priKeyFilePath') 
    4746         
    48         self.cookie.priKeyFilePath = configParser.get('setUp',  
    49                                                       'priKeyFilePath') 
     47        self.cookie.x509CertFilePath = configParser.get('setUp',  
     48                                                        'x509CertFilePath') 
    5049       
    5150        self.cookie.create('O=NDG/OU=BADC/CN=test', 
    52                            base64.encodestring(os.urandom(32)), 
     51                           base64.encodestring(os.urandom(32)).strip(), 
    5352                           'http://localhost:5000/SessionManager') 
    5453         
    55          
     54             
    5655    def test1GetSessID(self): 
    5756        """test1GetSessID: check session ID attribute"""        
     
    7372        """test5Parse: check parsing from string"""        
    7473        print "Test parse from string: \n" 
     74        newCookie = SessionCookie() 
     75        newCookie.priKeyPwd = self.__class__.priKeyPwd 
     76        newCookie.priKeyFilePath = self.priKeyFilePath 
    7577         
    76         cookie = SessionCookie.parse(str(self.cookie)) 
    77         print "Session ID: \n%s" % self.cookie.sessID 
    78         print "User DN: \n%s" % self.cookie.userDN 
    79         print "Session Manager URI: \n%s" % self.cookie.sessMgrURI 
     78        cookie = newCookie.parse(str(self.cookie)) 
     79        print "Session ID: \n%s" % newCookie.sessID 
     80        print "User DN: \n%s" % newCookie.userDN 
     81        print "Session Manager URI: \n%s" % newCookie.sessMgrURI 
    8082                   
    8183             
     
    8486     
    8587    def __init__(self): 
    86         map = map(SessionMgrClientTestCase, 
     88        map = map(SessionCookieTestCase, 
    8789                  ( 
    88                     "testParse", 
     90                    "test1GetSessID", 
     91                    "test2GetUserDN", 
     92                    "test3GetSessMgrURI", 
     93                    "test4AsString", 
     94                    "test5Parse", 
    8995                  )) 
    9096        unittest.TestSuite.__init__(self, map) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionMgr/SessionMgrClientTest.py

    r2530 r2620  
    3434class SessionMgrClientTestCase(unittest.TestCase): 
    3535    pemPat = "-----BEGIN CERTIFICATE-----[^\-]*-----END CERTIFICATE-----" 
     36         
     37    test2Passphrase = None 
     38    test3Passphrase = None 
    3639 
    3740    def _getCertChainFromProxyCertFile(self, proxyCertFilePath): 
     
    8891            signingCertChain = \ 
    8992                        self._getCertChainFromProxyCertFile(proxyCertFilePath) 
    90              
     93        else: 
     94            signingCertChain = None 
     95                 
    9196        setSignatureHandler = eval(self.cfg['setUp']['setsignaturehandler']) 
    9297             
     
    103108                tracefile=tracefile)  
    104109         
    105         self.sessCookie = None 
     110        self.sessID = None 
    106111        self.proxyCert = None 
    107112        self.proxyPriKey = None 
    108113        self.userCert = None 
    109114 
    110     def test1AddUser(self): 
    111         """Add a new user ID to the MyProxy repository""" 
    112          
    113         passphrase = self.cfg['test1AddUser'].get('passphrase') or \ 
    114             getpass.getpass(prompt="\ntest1AddUser pass-phrase for new user: ") 
    115              
    116         # Note the pass-phrase is read from the file tmp.  To pass 
    117         # explicitly as a string use the 'passphrase' keyword instead 
    118         self.clnt.addUser(self.cfg['test1AddUser']['username'],  
    119                           passphrase=passphrase) 
    120         print "Added user '%s'" % self.cfg['test1AddUser']['username'] 
    121          
    122  
    123     def test2CookieConnect(self): 
    124         """test2CookieConnect: Connect as if acting as a browser client -  
    125         a cookie is returned""" 
    126  
    127         passphrase = self.cfg['test2CookieConnect'].get('passphrase') 
    128         if passphrase is None: 
    129             passphrase = getpass.getpass(\ 
    130                      prompt="\ntest2CookieConnect pass-phrase for user: ") 
    131  
    132         self.proxyCert, self.proxyPriKey, self.userCert, cookie = \ 
    133             self.clnt.connect(self.cfg['test2CookieConnect']['username'],  
    134                               passphrase=passphrase, 
    135                               getCookie=True) 
    136  
    137         self.sessCookie = SessionCookie(cookie) 
     115# TODO: is addUser part of session manager? 
     116#    def test1AddUser(self): 
     117#        """Add a new user ID to the MyProxy repository""" 
     118#         
     119#        passphrase = self.cfg['test1AddUser'].get('passphrase') or \ 
     120#            getpass.getpass(prompt="\ntest1AddUser pass-phrase for new user: ") 
     121#             
     122#        # Note the pass-phrase is read from the file tmp.  To pass 
     123#        # explicitly as a string use the 'passphrase' keyword instead 
     124#        self.clnt.addUser(self.cfg['test1AddUser']['username'],  
     125#                          passphrase=passphrase) 
     126#        print "Added user '%s'" % self.cfg['test1AddUser']['username'] 
     127         
     128 
     129    def test2Connect(self): 
     130        """test2Connect: Connect as if acting as a browser client -  
     131        a session ID is returned""" 
     132         
     133        if self.__class__.test2Passphrase is None: 
     134            self.__class__.test2Passphrase = \ 
     135                                    self.cfg['test2Connect'].get('passphrase') 
     136         
     137        if not self.__class__.test2Passphrase: 
     138            self.__class__.test2Passphrase = getpass.getpass(\ 
     139                               prompt="\ntest2Connect pass-phrase for user: ") 
     140 
     141        self.proxyCert, self.proxyPriKey, self.userCert, self.sessID = \ 
     142            self.clnt.connect(self.cfg['test2Connect']['username'],  
     143                              passphrase=self.__class__.test2Passphrase) 
     144 
    138145        print "User '%s' connected to Session Manager:\n%s" % \ 
    139             (self.cfg['test2CookieConnect']['username'], self.sessCookie) 
    140              
    141  
    142     def test3ProxyCertConnect(self): 
    143         """test3ProxyCertConnect: Connect as a command line client -  
    144         a proxyCert is returned""" 
    145  
    146         passphrase = self.cfg['test3ProxyCertConnect'].get('passphrase') or \ 
    147             getpass.getpass(\ 
    148                     prompt="\ntest3ProxyCertConnect pass-phrase for user: ") 
    149  
    150         self.proxyCert, self.proxyPriKey, self.userCert, null = \ 
    151             self.clnt.connect(self.cfg['test3ProxyCertConnect']['username'],  
    152                               passphrase=passphrase, 
    153                               getCookie=False) 
     146            (self.cfg['test2Connect']['username'], self.sessID) 
     147             
     148 
     149    def test3ConnectNoCreateServerSess(self): 
     150        """test3ConnectNoCreateServerSess: Connect as a non browser client -  
     151        sessID should be None""" 
     152 
     153        if self.__class__.test3Passphrase is None: 
     154            self.__class__.test3Passphrase = \ 
     155                self.cfg['test3ConnectNoCreateServerSess'].get('passphrase') 
     156                 
     157        if not self.__class__.test3Passphrase: 
     158            self.__class__.test3Passphrase = getpass.getpass(\ 
     159            prompt="\ntest3ConnectNoCreateServerSess pass-phrase for user: ") 
     160 
     161        self.proxyCert, self.proxyPriKey, self.userCert, sessID = \ 
     162            self.clnt.connect(\ 
     163                      self.cfg['test3ConnectNoCreateServerSess']['username'],  
     164                      passphrase=self.__class__.test3Passphrase, 
     165                      createServerSess=False) 
     166         
     167        # Expect null session ID 
     168        assert(not sessID) 
     169           
    154170        print "User '%s' connected to Session Manager:\n%s" % \ 
    155             (self.cfg['test3ProxyCertConnect']['username'], self.proxyCert) 
    156              
    157  
    158     def test4CookieDisconnect(self): 
    159         """test4CookieDisconnect: disconnect as if acting as a browser client  
     171                    (self.cfg['test3ConnectNoCreateServerSess']['username'],  
     172                     self.proxyCert) 
     173             
     174 
     175    def test4DisconnectUsingSessID(self): 
     176        """test4DisconnectUsingSessID: disconnect as if acting as a browser client  
    160177        """ 
    161178         
    162         print "\n\t" + self.test4CookieDisconnect.__doc__ 
    163         self.test2CookieConnect() 
     179        print "\n\t" + self.test4DisconnectUsingSessID.__doc__ 
     180        self.test2Connect() 
     181         
     182        self.clnt.disconnect(sessID=self.sessID) 
     183         
     184        print "User disconnected from Session Manager:\n%s" % self.sessID 
     185             
     186 
     187    def test5DisconnectUsingProxyCert(self): 
     188        """test5DisconnectUsingProxyCert: Disconnect as a command line client  
     189        """ 
     190         
     191        print "\n\t" + self.test5DisconnectUsingProxyCert.__doc__ 
     192        self.test2Connect() 
    164193         
    165194        # Use proxy cert / private key just obtained from connect call for 
    166         # signature generation 
    167         self.clnt.signatureHandler.signingCert = self.proxyCert 
    168         self.clnt.signatureHandler.signingCertPriKey = self.proxyPriKey 
    169         import pdb;pdb.set_trace() 
    170         self.clnt.disconnect(sessCookie=str(self.sessCookie)) 
    171          
    172         print "User disconnected from Session Manager:\n%s" % self.sessCookie 
    173              
    174  
    175     def test5ProxyCertDisconnect(self): 
    176         """test5ProxyCertDisconnect: Disconnect as a command line client  
    177         """ 
    178          
    179         print "\n\t" + self.test5ProxyCertDisconnect.__doc__ 
    180         self.test3ProxyCertConnect() 
    181          
    182         # Use proxy to sign outbound SOAP message 
    183         self.clnt.signingCert = self.proxyCert 
    184         self.clnt.signingKey = self.proxyPriKey 
    185         self.clnt.signingPriKeyPwd = None 
    186          
    187         # Proxy cert in signature determines ID of session to  
     195        # signature generation          
     196        self.clnt.signatureHandler.reqBinSecTokValType = 'X509PKIPathv1' 
     197        self.clnt.signatureHandler.signingPriKey = self.proxyPriKey         
     198        self.clnt.signatureHandler.signingCertChain = (self.userCert, 
     199                                                       self.proxyCert) 
     200         
     201        # Proxy cert in signature determines ID of session to 
    188202        # delete 
    189203        self.clnt.disconnect() 
     
    191205 
    192206 
    193     def test6CookieGetAttCert(self): 
    194         """test6CookieGetAttCert: make an attribute request using 
    195         a cookie as authentication credential""" 
    196  
    197         print "\n\t" + self.test6CookieGetAttCert.__doc__         
    198         self.test2CookieConnect() 
     207    def test6GetAttCertUsingSessID(self): 
     208        """test6GetAttCertUsingSessID: make an attribute request using 
     209        a session ID as authentication credential""" 
     210 
     211        print "\n\t" + self.test6GetAttCertUsingSessID.__doc__         
     212        self.test2Connect() 
    199213         
    200214        attCert, extAttCertList = self.clnt.getAttCert(\ 
    201             sessID=self.sessCookie.sessionID,  
    202             encrSessionMgrURI=self.sessCookie.encrSessionMgrURI, 
    203             attAuthorityURI=self.cfg['test6CookieGetAttCert']['aauri']) 
     215            sessID=self.sessID,  
     216            attAuthorityURI=self.cfg['test6GetAttCertUsingSessID']['aauri']) 
    204217         
    205218        print "Attribute Certificate:\n%s" % attCert   
     
    207220 
    208221 
    209     def test6aCookieGetAttCertRefused(self): 
    210         """test6aCookieGetAttCertRefused: make an attribute request using 
    211         a cookie as authentication credential requesting an AC from an 
     222    def test6aGetAttCertRefusedUsingSessID(self): 
     223        """test6aGetAttCertRefusedUsingSessID: make an attribute request using 
     224        a sessID as authentication credential requesting an AC from an 
    212225        Attribute Authority where the user is NOT registered""" 
    213226 
    214         print "\n\t" + self.test6aCookieGetAttCertRefused.__doc__         
    215         self.test2CookieConnect() 
    216          
    217         aaURI = self.cfg['test6aCookieGetAttCertRefused']['aauri'] 
     227        print "\n\t" + self.test6aGetAttCertRefusedUsingSessID.__doc__         
     228        self.test2Connect() 
     229         
     230        aaURI = self.cfg['test6aGetAttCertRefusedUsingSessID']['aauri'] 
    218231         
    219232        try: 
    220233            attCert, extAttCertList = self.clnt.getAttCert(\ 
    221                         sessID=self.sessCookie.sessionID,  
    222                         encrSessionMgrURI=self.sessCookie.encrSessionMgrURI, 
    223                         attAuthorityURI=aaURI, 
    224                         mapFromTrustedHosts=False) 
     234                                                    sessID=self.sessID,  
     235                                                    attAuthorityURI=aaURI, 
     236                                                    mapFromTrustedHosts=False) 
    225237        except AttributeRequestDenied, e: 
    226238            print "SUCCESS - obtained expected result: %s" % e 
     
    230242 
    231243 
    232     def test6bCookieGetMappedAttCert(self): 
    233         """test6bCookieGetMappedAttCert: make an attribute request using 
    234         a cookie as authentication credential""" 
    235  
    236         print "\n\t" + self.test6bCookieGetMappedAttCert.__doc__         
    237         self.test2CookieConnect() 
    238          
    239         attCert, extAttCertList = self.clnt.getAttCert(\ 
    240             sessID=self.sessCookie.sessionID,  
    241             encrSessionMgrURI=self.sessCookie.encrSessionMgrURI, 
    242             attAuthorityURI=self.cfg['test6bCookieGetMappedAttCert']['aauri']) 
     244    def test6bGetMappedAttCertUsingSessID(self): 
     245        """test6bGetMappedAttCertUsingSessID: make an attribute request using 
     246        a session ID as authentication credential""" 
     247 
     248        print "\n\t" + self.test6bGetMappedAttCertUsingSessID.__doc__         
     249        self.test2Connect() 
     250         
     251        aaURI = self.cfg['test6bGetMappedAttCertUsingSessID']['aauri'] 
     252         
     253        attCert, extAttCertList = self.clnt.getAttCert(sessID=self.sessID,  
     254                                                       attAuthorityURI=aaURI) 
    243255         
    244256        print "Attribute Certificate:\n%s" % attCert   
     
    246258 
    247259 
    248     def test6cCookieGetAttCertWithExtAttCertList(self): 
    249         """test6CookieGetAttCert: make an attribute request using 
    250         a cookie as authentication credential""" 
    251          
    252         print "\n\t" + self.test6cCookieGetAttCertWithExtAttCertList.__doc__         
    253         self.test2CookieConnect() 
     260    def test6cGetAttCertWithExtAttCertListUsingSessID(self): 
     261        """test6GetAttCertUsingSessID: make an attribute request using 
     262        a session ID as authentication credential""" 
     263         
     264        print "\n\t" + \ 
     265            self.test6cGetAttCertWithExtAttCertListUsingSessID.__doc__         
     266        self.test2Connect() 
    254267         
    255268        aaURI = \ 
    256             self.cfg['test6cCookieGetAttCertWithExtAttCertList']['aauri'] 
     269            self.cfg['test6cGetAttCertWithExtAttCertListUsingSessID']['aauri'] 
    257270             
    258271        attCert, extAttCertList = self.clnt.getAttCert(\ 
    259                         sessID=self.sessCookie.sessionID,  
    260                         encrSessionMgrURI=self.sessCookie.encrSessionMgrURI, 
    261                         attAuthorityURI=aaURI, 
    262                         extAttCertList=['AC1', 'AC2', 'AC3']) 
     272                                        sessID=self.sessID,  
     273                                        attAuthorityURI=aaURI, 
     274                                        extAttCertList=['AC1', 'AC2', 'AC3']) 
    263275           
    264276        print "Attribute Certificate:\n%s" % attCert   
     
    266278 
    267279 
    268     def test7ProxyCertGetAttCert(self): 
    269         """test7ProxyCertGetAttCert: make an attribute request using 
     280    def test7GetAttCertUsingProxyCert(self): 
     281        """test7GetAttCertUsingProxyCert: make an attribute request using 
    270282        a proxy cert as authentication credential""" 
    271         print "\n\t" + self.test7ProxyCertGetAttCert.__doc__ 
    272         self.test3ProxyCertConnect() 
     283        print "\n\t" + self.test7GetAttCertUsingProxyCert.__doc__ 
     284        self.test2Connect() 
     285 
     286        self.clnt.signatureHandler.reqBinSecTokValType = 'X509PKIPathv1' 
     287        self.clnt.signatureHandler.signingPriKey = self.proxyPriKey         
     288        self.clnt.signatureHandler.signingCertChain = (self.userCert, 
     289                                                       self.proxyCert) 
    273290         
    274291        # Request an attribute certificate from an Attribute Authority  
    275292        # using the proxyCert returned from connect() 
    276293         
    277         aaURI = self.cfg['test7ProxyCertGetAttCert']['aauri'] 
    278         attCert, extAttCertList = self.clnt.getAttCert(\ 
    279                                                  proxyCert=self.proxyCert, 
    280                                                  attAuthorityURI=aaURI) 
     294        aaURI = self.cfg['test7GetAttCertUsingProxyCert']['aauri'] 
     295        attCert, extAttCertList = self.clnt.getAttCert(attAuthorityURI=aaURI) 
    281296           
    282297        print "Attribute Certificate:\n%s" % attCert   
     
    298313                  ( 
    299314                    "test1AddUser", 
    300                     "test2CookieConnect", 
    301                     "test3ProxyCertConnect", 
    302                     "test4CookieDisconnect", 
    303                     "test5ProxyCertDisconnect", 
    304                     "test6CookieGetAttCert", 
    305                     "test6bCookieGetMappedAttCert", 
    306                     "test6cCookieGetAttCertWithExtAttCertList", 
    307                     "test7ProxyCertGetAttCert", 
     315                    "test2Connect", 
     316                    "test3ConnectNoCreateServerSess", 
     317                    "test4DisconnectUsingSessID", 
     318                    "test5DisconnectUsingProxyCert", 
     319                    "test6GetAttCertUsingSessID", 
     320                    "test6bGetMappedAttCertUsingSessID", 
     321                    "test6cGetAttCertWithExtAttCertListUsingSessID", 
     322                    "test7GetAttCertUsingProxyCert", 
    308323                    "test8GetX509Cert", 
    309324                  )) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionMgr/sessionMgrClientTest.cfg

    r2530 r2620  
    1717# ValueType for BinarySecurityToken element of WSSE header.  Specify 
    1818# 'X509PKIPathv1' for use with proxy certificates 
    19 #reqbinsectokvaltype = X509v3 
     19reqbinsectokvaltype = X509v3 
    2020#reqbinsectokvaltype = X509 
    21 reqbinsectokvaltype = X509PKIPathv1 
     21#reqbinsectokvaltype = X509PKIPathv1 
    2222 
    2323# Test with proxy certificates or with standard certs.  Comment out as  
    2424# appropriate 
    25 proxycertfilepath = ./proxy-cert.pem 
     25#proxycertfilepath = ./proxy-cert.pem 
    2626 
    2727# Test without proxy certificates - uses AA server side cert/private key for 
    2828# client side too (!) 
    29 #clntcertfilepath = ./clnt-cert.pem 
     29clntcertfilepath = ./clnt-cert.pem 
    3030 
    31 #clntprikeyfilepath = ./clnt-key.pem 
    32 clntprikeyfilepath = ./proxy-key.pem 
     31clntprikeyfilepath = ./clnt-key.pem 
     32#clntprikeyfilepath = ./proxy-key.pem 
    3333 
    3434# Password protecting client private key - if omitted it will be prompted for 
     
    4545#passphrase = 
    4646  
    47 [test2CookieConnect]          
     47[test2Connect]          
    4848username = raphaelTest 
    4949#username = gabriel 
    5050#passphrase =  
    5151 
    52 [test3ProxyCertConnect]          
     52[test3ConnectNoCreateServerSess]          
    5353username = raphaelTest 
    5454#username = gabriel 
    5555#passphrase =  
    5656 
    57 [test6CookieGetAttCert] 
     57[test6GetAttCertUsingSessID] 
    5858aaURI = http://localhost:5000/AttributeAuthority 
    5959 
    60 [test6aCookieGetAttCertRefused] 
     60[test6aGetAttCertRefusedUsingSessID] 
    6161aaURI = http://localhost:5100/AttributeAuthority 
    6262 
    63 [test6bCookieGetMappedAttCert] 
     63[test6bGetMappedAttCertUsingSessID] 
    6464aaURI = http://localhost:5100/AttributeAuthority 
    6565 
    66 [test6cCookieGetAttCertWithExtAttCertList] 
     66[test6cGetAttCertWithExtAttCertListUsingSessID] 
    6767aaURI = http://localhost:5100/AttributeAuthority 
    6868 
    69 [test7ProxyCertGetAttCert] 
     69[test7GetAttCertUsingProxyCert] 
    7070aaURI = http://localhost:5000/AttributeAuthority 
    7171 
  • TI12-security/trunk/python/www/html/sessionMgr.wsdl

    r2437 r2620  
    3131            <xsd:element name="passphrase" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
    3232                    <xsd:element name="createServerSess" type="xsd:boolean" minOccurs="1" maxOccurs="1"/> 
    33                     <xsd:element name="getCookie" type="xsd:boolean" minOccurs="1" maxOccurs="1"/> 
    3433          </xsd:sequence> 
    3534        </xsd:complexType> 
     
    4241                    <xsd:element name="proxyPriKey" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
    4342                    <xsd:element name="userCert" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
    44                     <xsd:element name="cookie" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     43                    <xsd:element name="sessID" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    4544                  </xsd:sequence> 
    4645                </xsd:complexType> 
     
    5049        <xsd:complexType> 
    5150                  <xsd:sequence> 
     51                    <xsd:element name="userCert" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    5252                    <xsd:element name="sessID" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    53                     <xsd:element name="encrSessionMgrURI" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    5453                  </xsd:sequence> 
    5554                </xsd:complexType> 
     
    6564                    <xsd:element name="userCert" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    6665                    <xsd:element name="sessID" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    67                     <xsd:element name="encrSessionMgrURI" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    6866                    <xsd:element name="attAuthorityURI" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
    6967                    <xsd:element name="attAuthorityCert" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
Note: See TracChangeset for help on using the changeset viewer.