Changeset 686


Ignore:
Timestamp:
21/03/06 17:50:30 (13 years ago)
Author:
pjkersha
Message:

ndgSessionClient:

  • replaced getopt with more up to date optparse command line parser
  • authorisation request can now receive a cookie as input instead of having to inclue explicit

session ID etc.

  • included new options for session manager and client X.509 cert settings.

sessionMgrProperties.xml:
revised tags - sessMgrWSDL* -> sessMgrEncr* and new key sessionMgrPubKeyURI.

SessionMgrServer?: --nowsdlencrkey becomes --noencrkey

X509: fixed bug in init X500DN needed explicit m2CryptoX509Name keyword.

AttCert?: fixed bug in contains method: self.tags should be self.dat.

XMLMsg:
init now more robust in that if xmlTxt parse fails, it will try a decrypt call if a
private key is available.

SessionMgrIO:
AuthorisationReq? class modified to include encrSessMgrPubKeyURI tag.

SessionClient?:

  • Major re-working to allow inclusion of client public key (for encryption of responses) and

Session Manager public key as either a file or a URI. Part completed.

  • reqAuthorisation now takes a session cookie as input rather than individual ID, WSDL address

etc. ... args.

Session.py:

  • New cookie NDG-ID3 sets encrypted URI for Session Manager public key.
  • encrypt/decrypt static methods added to UserSessino? class - moved from SessionMgr? class

(encryptSessMgrWSDLuri and decryptSessMgrWSDLuri methods)

  • SessionMgr? now inherits from dict. File Properties are available as dictionary keys.
  • Added new method redirectAuthorisationReq() to SessionMgr? to encapsulate code for Session

Manager request forwarding. Includes code to pick up public key of session manager from cookie
to enable encryption of the forwarded request.

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

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/NDG/AttCert.py

    r674 r686  
    105105        self.__dtNotAfter = None 
    106106 
    107  
    108  
    109107         
    110108    def __repr__(self): 
     
    114112                 
    115113    def __delitem__(self, key): 
    116  
    117114        "Attribute Certificate keys cannot be removed" 
    118115         
     
    122119 
    123120    def __getitem__(self, key): 
    124  
    125121        self.__class__.__name__ + """ behaves as data dictionary of Attribute 
    126122        Certificate properties 
     
    154150 
    155151 
    156     def __setitem__(self, key, item): 
    157          
     152    def __setitem__(self, key, item):         
    158153        self.__class__.__name__ + """ behaves as data dictionary of Attribute 
    159154        Certificate properties 
     
    232227    # 'in' operator 
    233228    def __contains__(self, key): 
    234         return key in self.__tags 
     229        return key in self.__dat 
    235230 
    236231 
  • TI12-security/trunk/python/NDG/Session.py

    r674 r686  
    7575    __sessIDlen = 128 
    7676 
    77     __cookieTags = ("NDG-ID1", "NDG-ID2") 
     77    __cookieTags = ("NDG-ID1", "NDG-ID2", "NDG-ID3") 
    7878 
    7979    # Follow standard format for cookie path and expiry attributes 
     
    8888    def __init__(self, *credWalletArgs, **credWalletKeys): 
    8989        """Initialise UserSession with args and keywords to CredWallet""" 
    90          
     90 
    9191        # Domain for cookie used by createCookie method - if not set, default 
    9292        # is web server domain name 
     
    140140                          doc="Read-only access to Session ID list") 
    141141 
    142          
     142 
     143    #_________________________________________________________________________         
    143144    def __latestSessID(self): 
    144145        """Get the session ID most recently allocated""" 
     
    150151 
    151152 
     153    #_________________________________________________________________________ 
    152154    def __createSessID(self): 
    153155        """Add a new session ID to be associated with this UserSession 
     
    162164 
    163165 
     166    #_________________________________________________________________________ 
    164167    def __getExpiryStr(self): 
    165168        """Return session expiry date/time as would formatted for a cookie""" 
     
    172175        except Exception, e: 
    173176            UserSessionError("getExpiry: %s" % e) 
    174              
    175      
     177 
     178 
     179    #_________________________________________________________________________ 
     180    @staticmethod 
     181    def encrypt(txt, encrKey): 
     182        """Encrypt the test of this Session Manager's WS URI / URI for its 
     183        public key to allow inclusion in a web browser session cookie 
     184         
     185        The address is encrypted and then base 64 encoded""" 
     186         
     187        # Text length must be a multiple of 16 for AES encryption 
     188        try: 
     189            mod = len(txt) % 16 
     190            if mod: 
     191                nPad = 16 - mod 
     192            else: 
     193                nPad = 0 
     194                 
     195            # Add padding 
     196            paddedURI = txt + ''.join([' ' for i in range(nPad)]) 
     197        except Exception, e: 
     198            raise UserSessionError("Error padding text for encryption: " + \ 
     199                                   str(e)) 
     200         
     201        # encrypt 
     202        try: 
     203            aes = AES.new(encrKey, AES.MODE_ECB) 
     204            return base64.b64encode(aes.encrypt(paddedURI)) 
     205         
     206        except Exception, e: 
     207            raise UserSessionError("Error encrypting text: %s" % str(e)) 
     208                                        
     209     
     210    #_________________________________________________________________________ 
     211    @staticmethod                                    
     212    def decrypt(encrTxt, encrKey): 
     213        """Decrypt text from cookie set by another Session Manager.  This 
     214        is required when reading a session cookie to find out which  
     215        Session Manager holds the client's session 
     216         
     217        encrTxt:    base 64 encoded encrypted text""" 
     218 
     219        try: 
     220            aes = AES.new(encrKey, AES.MODE_ECB) 
     221             
     222            # Decode from base 64 
     223            b64DecodedEncrTxt=base64.b64decode(encrTxt) 
     224             
     225            # Decrypt and strip trailing spaces 
     226            return aes.decrypt(b64DecodedEncrTxt).strip() 
     227         
     228        except Exception, e: 
     229            raise SessionMgrError("Decrypting: %s" % str(e))             
     230 
     231 
     232    #_________________________________________________________________________ 
    176233    def createCookie(self,  
    177                      encrSessMgrWSDLuri,  
     234                     sessMgrWSDLuri, 
     235                     sessMgrPubKeyURI, 
     236                     encrKey,  
    178237                     sessID=None, 
    179238                     cookieDomain=None, 
     
    181240        """Create cookies for session ID Session Manager WSDL address 
    182241 
    183         encrSessMgrWSDLuri:    encrypted WSDL address for Session Mananger  
    184                                WSDL 
     242        sessMgrWSDLuri:     WSDL address for Session Mananger  
     243        sessMgrPubKeyURI:   URI for public key of Session Manager 
     244        encrKey:               encryption key used to encrypted above URIs 
    185245        sessID:                if no session ID is provided, use the latest  
    186246                               one to be allocated. 
     
    190250                               text.  If False, it is returned as a  
    191251                               SimpleCookie instance.""" 
    192  
    193         if not encrSessMgrWSDLuri: 
    194             raise UserSessionError("No encrypted WSDL address set") 
    195                              
    196         elif not isinstance(encrSessMgrWSDLuri, basestring): 
    197             raise UserSessionError(\ 
    198                             "Encrypted WSDL address must be a valid string") 
    199              
    200              
    201         # Try to ensure WSDL address has been passed encrypted 
    202         if encrSessMgrWSDLuri.find("http://") != -1 or \ 
    203            encrSessMgrWSDLuri.find("https://") != -1: 
    204                raise UserSessionError(\ 
    205            "Session Manager WSDL address appears not to be encrypted: %s" % \ 
    206            encrSessMgrWSDLuri) 
    207         else: 
    208             # Sledge hammer approach 
    209             try: 
    210                 urlopen(encrSessMgrWSDLuri) 
    211                 raise UserSessionError(\ 
    212            "Session Manager WSDL address appears not to be encrypted: %s" % \ 
    213            encrSessMgrWSDLuri) 
    214                  
    215             except: 
    216                 pass    
    217252 
    218253 
     
    238273            sessCookie = SimpleCookie() 
    239274             
    240             tagValues = (sessID, encrSessMgrWSDLuri) 
     275            tagValues = (sessID,  
     276                         self.encrypt(sessMgrWSDLuri, encrKey), 
     277                         self.encrypt(sessMgrPubKeyURI, encrKey)) 
     278                          
    241279            expiryStr = self.__getExpiryStr() 
    242280             
    243281            i=0 
    244282            for tag in self.__cookieTags: 
    245      
     283                 
    246284                sessCookie[tag] = tagValues[i] 
    247285                i += 1 
     
    282320 
    283321#_____________________________________________________________________________ 
    284 class SessionMgr(object): 
     322class SessionMgr(dict): 
    285323    """NDG authentication and session handling""" 
    286324 
     
    290328                       'keyFile', 
    291329                       'keyPPhrase',  
    292                        'sessMgrWSDLkey',  
     330                       'sessMgrEncrKey',  
    293331                       'sessMgrWSDLuri', 
     332                       'sessMgrPubKeyURI', 
    294333                       'cookieDomain',  
    295334                       'myProxyProp',  
     
    310349                             tags in the properties file"""         
    311350 
     351        # Base class initialisation 
     352        dict.__init__(self) 
     353         
     354 
    312355        # MyProxy interface 
    313356        try: 
     
    343386        # will overwrite the latter 
    344387        self.setProperties(**prop) 
     388      
     389         
     390    #_________________________________________________________________________         
     391    def __delitem__(self, key): 
     392        "Session Manager keys cannot be removed"         
     393        raise KeyError('Keys cannot be deleted from '+self.__class__.__name__) 
     394 
     395 
     396    def __getitem__(self, key): 
     397        self.__class__.__name__ + """ behaves as data dictionary of Session 
     398        Manager properties 
     399 
     400        Nb. also possible to apply keys belonging validity and attributes 
     401        sub dictionaries 
     402        """ 
     403        if key not in self.__prop: 
     404            raise KeyError("Invalid key " + key) 
     405         
     406        return self.__prop[key] 
     407     
     408     
     409    def __setitem__(self, key, item): 
     410        self.__class__.__name__ + """ behaves as data dictionary of Session 
     411        Manager properties""" 
     412        self.setProperties(**{key: item}) 
     413         
     414 
     415    def clear(self): 
     416        raise KeyError("Data cannot be cleared from "+self.__class__.__name__) 
     417    
     418    def keys(self): 
     419        return self.__prop.keys() 
     420 
     421    def items(self): 
     422        return self.__prop.items() 
     423 
     424    def values(self): 
     425        return self.__prop.values() 
     426 
     427    def has_key(self, key): 
     428        return self.__prop.has_key(key) 
     429 
     430    # 'in' operator 
     431    def __contains__(self, key): 
     432        return key in self.__prop 
    345433             
    346434 
     
    609697                # Web browser client - Return session cookie 
    610698                userSess.cookieDomain = self.__prop['cookieDomain'] 
    611                 sessCookie = userSess.createCookie(self.encrSessMgrWSDLuri) 
     699                sessCookie = userSess.createCookie(\ 
     700                                            self.__prop['sessMgrWSDLuri'], 
     701                                            self.__prop['sessMgrPubKeyURI'], 
     702                                            self.__prop['sessMgrEncrKey']) 
    612703                 
    613704                try: 
     
    752843 
    753844 
    754     def __encryptSessMgrWSDLuri(self): 
    755         """Encrypt the WSDL address of this Session Manager's WS to allow 
    756         inclusion in a web browser session cookie 
    757          
    758         The address is encrypted and then base 64 encoded""" 
    759          
    760         # Text length must be a multiple of 16 for AES encryption 
    761         try: 
    762             mod = len(self.__prop['sessMgrWSDLuri']) % 16 
    763             if mod: 
    764                 nPad = 16 - mod 
    765             else: 
    766                 nPad = 0 
    767                  
    768             # Add padding 
    769             paddedURI = self.__prop['sessMgrWSDLuri'] + \ 
    770                         ''.join([' ' for i in range(nPad)]) 
    771         except Exception, e: 
    772             raise SessionMgrError("Error padding WSDL URI: %s" % e) 
    773          
    774         # encrypt 
    775         try: 
    776             aes = AES.new(self.__prop['sessMgrWSDLkey'], AES.MODE_ECB) 
    777             return base64.b64encode(aes.encrypt(paddedURI)) 
    778          
    779         except Exception, e: 
    780             raise SessionMgrError("Error encrypting WSDL URI: %s" % e) 
    781  
    782  
    783     # Make available as read-only attribute 
    784     encrSessMgrWSDLuri = property(fget=__encryptSessMgrWSDLuri, 
    785                                   doc="Encrypted SessionMgr WSDL Address") 
    786                                         
    787                                         
    788     def decryptSessMgrWSDLuri(self, encrSessMgrWSDLuri): 
    789         """Decrypt the WSDL address of another Session Manager.  This 
    790         is required when reading a session cookie to find out which  
    791         Session Manager holds the client's session 
    792          
    793         encrSessMgrWSDLuri:    base 64 encoded encrypted WSDL address""" 
    794  
    795         try: 
    796             aes = AES.new(self.__prop['sessMgrWSDLkey'], AES.MODE_ECB) 
    797              
    798             # Decode from base 64 
    799             b64DecodedEncrSessMgrWSDLuri=base64.b64decode(encrSessMgrWSDLuri) 
    800              
    801             # Decrypt and strip trailing spaces 
    802             return aes.decrypt(b64DecodedEncrSessMgrWSDLuri).strip() 
    803          
    804         except Exception, e: 
    805             raise SessionMgrError("Error encrypting WSDL URI: %s" % e) 
    806  
    807845 
    808846    #_________________________________________________________________________ 
     
    812850        returned. 
    813851 
    814         **reqKeys:              keywords used by  
     852        reqXMLtxt:            pass formatted XML request - see SessionMgrIO 
     853                              AuthorisationReq class for details 
     854        **reqKeys:            pass equivalent to XML as keywords instead 
    815855        """ 
    816  
    817         if reqXMLtxt is not None: 
    818             # Parse XML text into keywords corresponding to the input 
    819             # parameters 
    820             if not isinstance(reqXMLtxt, basestring): 
    821                 raise SessionMgrError(\ 
    822                             "XML Authorisation request must be a string") 
    823                                         
    824             # Parse and decrypt as necessary 
     856         
     857        # Parse XML text into keywords corresponding to the input parameters 
     858        if reqXMLtxt: 
    825859            try: 
    826                 # 1st assume that the request was encrypted 
    827                 reqKeys = AuthorisationReq(encrXMLtxt=reqXMLtxt, 
     860                reqKeys = AuthorisationReq(xmlTxt=reqXMLtxt, 
    828861                                    encrPriKeyFilePath=self.__prop['keyFile'], 
    829862                                    encrPriKeyPwd=self.__prop['keyPPhrase']) 
    830863            except Exception, e: 
    831                  
    832                 # Error occured decrypting - Trying parsing again, but this  
    833                 # time assuming non-encrypted 
    834                 try: 
    835                     reqKeys = AuthorisationReq(xmlTxt=reqXMLtxt) 
    836                      
    837                 except Exception, e: 
    838                     raise SessionMgrError(\ 
    839                         "Error parsing authorisation request: %s" % e) 
    840  
    841          
     864                raise SessionMgrError(\ 
     865                            "Error parsing authorisation request: " + str(e)) 
     866 
     867         
     868        # Web browser client input will include the encrypted address of the 
     869        # Session Manager where the user's session is held. 
    842870        if 'encrSessMgrWSDLuri' in reqKeys: 
     871             
    843872            # Decrypt the URI for where the user's session resides 
    844             userSessMgrWSDLuri = self.decryptSessMgrWSDLuri(\ 
    845                                                 reqKeys['encrSessMgrWSDLuri']) 
    846      
    847                                             
     873            userSessMgrWSDLuri = UserSession.decrypt(\ 
     874                                                reqKeys['encrSessMgrWSDLuri'], 
     875                                                self.__prop['sessMgrEncrKey']) 
     876                                                
    848877            # Check the address against the address of THIS Session Manager   
    849878            if userSessMgrWSDLuri != self.__prop['sessMgrWSDLuri']: 
    850                 # User session resides on another Session Manager - forward the 
    851                 # request 
    852                  
    853                 # Instantiate WS proxy for remote session manager 
    854                 try: 
    855                     smSrv = ServiceProxy(userSessMgrWSDLuri, use_wsdl=True) 
    856                 except Exception, e: 
    857                     raise SessionMgrError(\ 
    858                         "Error initialising WS for \"%s\": %s" % \ 
    859                         (userSessMgrWSDLuri, e)) 
    860                  
    861                  
    862                 # Call remote session manager's authorisation request method 
    863                 # and return result to caller 
    864                 # 
    865                 # TODO: Message level encryption public key of target SessionMgr 
    866                 # is needed here in order to be able to apply message level  
    867                 # encryption.  Get from cookie?? 
    868                 # 
    869                 # P J Kershaw 02/03/06 
    870                 try:     
    871                     # Format parsed request into a new request encrypted by the 
    872                     # target SessionMgr's public key 
    873                     redirectAuthReq = AuthorisationReq(\ 
    874                                         #encrPubKeyFilePath=userSessMgrPubKeyURI, 
    875                                         **dict(reqKeys.items())) 
    876                                          
    877                     # Call remote SessionMgr where users session lies 
    878                     redirectAuthResp = smSrv.reqAuthorisation(\ 
    879                                             authorisationReq=redirectAuthReq()) 
    880                    
    881                     # Parse XML contained in response                   
    882                     resp = AuthorisationResp(\ 
    883                             xmlTxt=str(redirectAuthResp['authorisationResp'])) 
    884                     return resp 
    885                  
    886                 except Exception, e: 
    887                     raise SessionMgrError(\ 
    888                     "Error requesting authorisation for Session Manager %s: %s" %\ 
    889                     (userSessMgrWSDLuri, e)) 
     879                # Session is held on a remote Session  Manager 
     880                return self.__redirectAuthorisationReq() 
     881 
    890882             
    891883        # User's session resides with THIS Session Manager / no encrypted 
     
    910902        # Copy keywords to be passed onto the request to the attribute  
    911903        # authority 
    912         aaKeys = dict(reqKeys.items()) 
    913          
    914         # ID keys aren't required 
    915         try: del aaKeys['sessID'] 
    916         except KeyError: pass 
    917          
    918         try: del aaKeys['encrSessMgrWSDLuri'] 
    919         except KeyError: pass 
    920          
    921         try: del aaKeys['proxyCert'] 
    922         except KeyError: pass 
     904        # 
     905        # Nb. the following keys aren't required 
     906        delKeys = ('proxyCert', 
     907                   'sessID',  
     908                   'encrSessMgrWSDLuri',  
     909                   'encrSessMgrPubKeyURI') 
     910                    
     911        aaKeys = dict([i for i in reqKeys.items() if i[0] not in delKeys]) 
     912                 
    923913         
    924914        # Ensure CA certificate file is set 
     
    955945            # allow dictionary-like access to XML tags 
    956946            resp = AuthorisationResp(attCert=attCert,  
    957                                      statCode=AuthorisationResp.accessGranted) 
     947                                     statCode=AuthorisationResp.accessGranted, 
     948                                     encrPubKeyFilePath=clntPubKeyFilePath) 
    958949             
    959950        except CredWalletAuthorisationDenied, e: 
     
    963954            resp = AuthorisationResp(extAttCertList=e.extAttCertList, 
    964955                                     statCode=AuthorisationResp.accessDenied, 
    965                                      errMsg=str(e)) 
     956                                     errMsg=str(e), 
     957                                     encrPubKeyFilePath=clntPubKeyFilePath) 
    966958         
    967959        except Exception, e: 
     
    969961            # response 
    970962            resp = AuthorisationResp(statCode=AuthorisationResp.accessError, 
    971                                      errMsg=str(e)) 
     963                                     errMsg=str(e), 
     964                                     encrPubKeyFilePath=clntPubKeyFilePath) 
    972965     
    973966        return resp 
     967 
     968 
     969    #_________________________________________________________________________ 
     970    def __redirectAuthorisationReq(self): 
     971        """Handle case where User session resides on another Session Manager - 
     972        forward the request""" 
     973         
     974        # Instantiate WS proxy for remote session manager 
     975        try: 
     976            smSrv = ServiceProxy(userSessMgrWSDLuri, use_wsdl=True) 
     977        except Exception, e: 
     978            raise SessionMgrError("Error initialising WS for \"%s\": %s" % \ 
     979                                  (userSessMgrWSDLuri, e)) 
     980         
     981         
     982        # Decrypt URI for public key of remote session manager.  The  
     983        # key is required to allow the forwarded message to be  
     984        # encrypted 
     985        userSessMgrPubKeyURI = UserSession.decrypt(\ 
     986                                            reqKeys['encrSessMgrPubKeyURI'], 
     987                                            self.__prop['sessMgrEncrKey']) 
     988 
     989        # Retrieve the public key from the URI 
     990        try: 
     991            userSessMgrPubKey = NamedTemporaryFile() 
     992            (fileName, httpResp) = urllib.urlretrieve(userSessMgrPubKeyURI, 
     993                                                      userSessMgrPubKey.name) 
     994        except Exception, e: 
     995            raise SessionMgrError("Error retrieving Session Manager " + \ 
     996                                  "public key from \"%s\": %s" % \ 
     997                                  (userSessMgrPubKeyURI, str(e))) 
     998 
     999        # Expecting plain text format for returned public key file 
     1000        # 404 error would come back as 'text/html' 
     1001        if 'text/plain' not in httpResp['Content-type']: 
     1002            raise SessionMgrError("Error retrieving Session Manager " + \ 
     1003                "public key from \"%s\": expecting \"plain/text\"" % \ 
     1004                userSessMgrPubKeyURI) 
     1005 
     1006 
     1007        # Get a copy of THIS Session Manager's public key so that the  
     1008        # remote Session Manager can use it to encrypt its reply 
     1009        try: 
     1010            encrCert = open(self.__prop['certFile']).read() 
     1011             
     1012        except IOError, (errNo, errMsg): 
     1013            raise SessionMgrError(\ 
     1014                "Reading Session Manager public key \"%s\": %s" % \ 
     1015                (self.__prop['certFile'], errMsg)) 
     1016                 
     1017        except Exception, e: 
     1018            raise SessionMgrError(\ 
     1019                            "Reading Session Manager public key: " + str(e)) 
     1020 
     1021             
     1022        # Call remote session manager's authorisation request method 
     1023        # and return result to caller 
     1024        try:               
     1025            # Format parsed request into a new request encrypted by  
     1026            # the target SessionMgr's public key 
     1027            redirectAuthReq = AuthorisationReq(\ 
     1028                                    encrPubKeyFilePath=userSessMgrPubKey.name, 
     1029                                    encrCert=encrCert, 
     1030                                    **dict(reqKeys.items())) 
     1031                                 
     1032            # Call remote SessionMgr where users session lies 
     1033            redirectAuthResp = smSrv.reqAuthorisation(\ 
     1034                                        authorisationReq=redirectAuthReq()) 
     1035           
     1036            # Decrypt and parse XML contained in response                   
     1037            resp = AuthorisationResp(\ 
     1038                        encrXMLtxt=str(redirectAuthResp['authorisationResp']), 
     1039                        encrPriKeyFilePath=self.__prop['keyFile'], 
     1040                        encrPriKeyPwd=self.__prop['keyPPhrase']) 
     1041            return resp 
     1042         
     1043        except Exception, e: 
     1044            raise SessionMgrError(\ 
     1045                "Error requesting authorisation for Session Manager %s: %s" %\ 
     1046                (userSessMgrWSDLuri, e)) 
    9741047 
    9751048 
  • TI12-security/trunk/python/NDG/SessionClient.py

    r662 r686  
    3838    """Client interface to Session Manager Web Service""" 
    3939     
     40    #_________________________________________________________________________ 
    4041    def __init__(self,  
    4142                 smWSDL=None,  
    42                  smEncrPubKeyFilePath=None, 
     43                 smPubKeyFilePath=None, 
     44                 smPubKeyURI=None, 
     45                 clntPubKeyFilePath=None, 
    4346                 traceFile=None): 
    4447        """ 
    4548        smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
    4649                                 will set the Service Proxy 
    47         smEncrPubKeyFilePath:    Public key of Session Manager used to encrypt 
    48                                  the outgoing message if required 
     50        smPubKeyFilePath|smPubKeyURI:     
     51                                 Public key of Session Manager used to encrypt 
     52                                 the outgoing message if required - set as a 
     53                                 path on the local file system or as a URI 
     54        clntPubKeyFilePath:      Public key of client.  This is passed to the 
     55                                 Session Manager so that it can encrypt 
     56                                 responses.  WARNING: if not set, responses 
     57                                 are returned as clear text 
    4958        traceFile:               set to file object such as sys.stderr to  
    5059                                 give extra WS debug information""" 
    5160 
     61        self.__smWSDL = None 
     62        self.__smPubKeyFilePath = None 
     63        self.__smPubKeyURI = None 
     64         
    5265        if smWSDL: 
    5366            self.__setSMwsdl(smWSDL) 
    54         else: 
    55             self.__smWSDL = None 
    56              
    57         if smEncrPubKeyFilePath: 
    58             self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
    59         else: 
    60             self.__smEncrPubKeyFilePath = None 
    61                  
     67             
     68        if smPubKeyFilePath: 
     69            self.__setSMpubKeyFilePath(smPubKeyFilePath) 
     70             
     71        elif smPubKeyURI: 
     72            self.__setSMpubKeyURI(smPubKeyURI) 
     73             
     74        if clntPubKeyFilePath: 
     75            self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
     76             
    6277        self.__traceFile = traceFile 
    6378 
     
    6883         
    6984 
     85    #_________________________________________________________________________ 
    7086    def __setSMwsdl(self, smWSDL): 
    7187         
     
    8096                       
    8197     
    82     def __setSMencrPubKeyFilePath(self, smEncrPubKeyFilePath): 
    83          
    84         if not isinstance(smEncrPubKeyFilePath, basestring): 
     98    #_________________________________________________________________________ 
     99    def __setSMpubKeyFilePath(self, smPubKeyFilePath): 
     100         
     101        if not isinstance(smPubKeyFilePath, basestring): 
    85102            raise SessionClientError(\ 
    86103                "Session Manager public key file path must be a valid string") 
    87104         
    88         self.__smEncrPubKeyFilePath = smEncrPubKeyFilePath 
    89          
    90     smEncrPubKeyFilePath = property(fset=__setSMencrPubKeyFilePath, 
     105        self.__smPubKeyFilePath = smPubKeyFilePath 
     106        self.__smPubKeyURI = None 
     107         
     108    smPubKeyFilePath = property(fset=__setSMpubKeyFilePath, 
    91109                            doc="Set Session Manager public key file path") 
    92110 
    93          
     111 
     112    #_________________________________________________________________________ 
     113    def __setSMpubKeyURI(self, smPubKeyURI): 
     114         
     115        if not isinstance(smPubKeyURI, basestring): 
     116            raise SessionClientError(\ 
     117                "Session Manager public key URI must be a valid string") 
     118         
     119        self.__smPubKeyURI = smPubKeyURI 
     120        self.__smPubKeyFilePath = None 
     121         
     122    smPubKeyURI = property(fset=__setSMpubKeyURI, 
     123                           doc="Set Session Manager public key URI") 
     124 
     125  
     126    #_________________________________________________________________________ 
     127    def __setClntPubKeyFilePath(self, clntPubKeyFilePath): 
     128         
     129        if not isinstance(clntPubKeyFilePath, basestring): 
     130            raise SessionClientError(\ 
     131                "Client public key file path must be a valid string") 
     132         
     133        self.__clntPubKeyFilePath = clntPubKeyFilePath 
     134        self.__clntPubKeyFilePath = None 
     135         
     136    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     137                                  doc="File path for client public key") 
     138 
     139        
    94140    #_________________________________________________________________________ 
    95141    def serviceProxy(self, smWSDL=None): 
     
    98144            self.__setSMwsdl(smWSDL) 
    99145 
    100         self.__smSrv = ServiceProxy(self.__smWSDL,  
    101                                     use_wsdl=True,  
    102                                     tracefile=self.__traceFile) 
    103  
     146        try: 
     147            self.__smSrv = ServiceProxy(self.__smWSDL,  
     148                                        use_wsdl=True,  
     149                                        tracefile=self.__traceFile) 
     150        except Exception, e: 
     151            raise SessionClientError("Initialising WSDL Service Proxy: " + \ 
     152                                     str(e)) 
    104153                                     
    105154    #_________________________________________________________________________ 
     
    107156                userName, 
    108157                pPhrase=None, 
    109                 pPhraseFilePath=None, 
    110                 smWSDL=None, 
    111                 smEncrPubKeyFilePath=None): 
     158                pPhraseFilePath=None): 
    112159        """Register a new user 
    113160         
     
    116163        pPhraseFilePath:         a file containing the user's pass-phrase.   
    117164                                 Use this as an alternative to pPhrase keyword 
    118         smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
    119                                  will reset the Service Proxy 
    120         smEncrPubKeyFilePath:    Public key of Session Manager used to encrypt 
    121                                  the outgoing message if required""" 
    122      
    123         if smWSDL: 
    124             self.serviceProxy(smWSDL) 
    125              
    126         if smEncrPubKeyFilePath: 
    127             self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
    128  
    129              
     165        """ 
     166     
    130167        if pPhrase is None: 
    131168            try: 
     
    140177            addUserReq = AddUserReq(userName=userName,  
    141178                                    pPhrase=pPhrase, 
    142                                     encrPubKeyFilePath=smEncrPubKeyFilePath)  
     179                                    encrCert=self.__clntPubKeyFilePath, 
     180                                    encrPubKeyFilePath=smPubKeyFilePath)  
    143181 
    144182            # Pass encrypted request 
     
    158196                pPhraseFilePath=None, 
    159197                getCookie=True, 
    160                 createServerSess=False, 
    161                 smWSDL=None, 
    162                 smEncrPubKeyFilePath=None): 
     198                createServerSess=False): 
    163199        """Request a new user session from the Session Manager 
    164200         
     
    181217                                 False, it's possible to choose to have a  
    182218                                 client or server side session using this  
    183                                  keyword. 
    184                                   
    185         smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
    186                                  will reset the Service Proxy. 
    187                                   
    188         smEncrPubKeyFilePath:    Public key of Session Manager used to encrypt 
    189                                  the outgoing message if required""" 
    190      
    191         if smWSDL: 
    192             self.serviceProxy(smWSDL) 
    193              
    194         if smEncrPubKeyFilePath: 
    195             self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
    196              
     219                                 keyword.""" 
     220     
    197221        if pPhrase is None: 
    198222            try: 
     
    206230        try:  
    207231            connectReq = ConnectReq(userName=userName,  
    208                             pPhrase=pPhrase, 
    209                             getCookie=getCookie, 
    210                             createServerSess=createServerSess, 
    211                             encrPubKeyFilePath=self.__smEncrPubKeyFilePath)  
     232                                pPhrase=pPhrase, 
     233                                getCookie=getCookie, 
     234                                createServerSess=createServerSess, 
     235                                encrCert=self.__clntPubKeyFilePath, 
     236                                encrPubKeyFilePath=self.__smPubKeyFilePath)  
    212237     
    213238            # Pass encrypted request 
     
    234259    #_________________________________________________________________________  
    235260    def reqAuthorisation(self, 
    236                          sessID=None, 
    237                          encrSessMgrWSDLuri=None, 
     261                         sessCookie=None, 
    238262                         proxyCert=None, 
    239                          smWSDL=None, 
    240263                         aaWSDL=None, 
    241264                         reqRole=None, 
     
    243266                         rtnExtAttCertList=False, 
    244267                         extAttCertList=None, 
    245                          extTrustedHostList=None, 
    246                          encrCert=None, 
    247                          smEncrPubKeyFilePath=None):     
     268                         extTrustedHostList=None):     
    248269        """Request authorisation from NDG Session Manager Web Service. 
    249270         
    250         sessID:                session ID returned with cookie from connect() 
    251         encrSessMgrWSDLuri:    encrypted Session Manager WSDL URI.  This is 
    252                                also returned in a cookie from a previous call 
    253                                to connect.  The Session Manager WS called - 
    254                                as set in self.__smWSDL - will decrypt and  
    255                                check encrSessMgrWSDLuri.  If the URI  
    256                                corresponds to a different Session Manager, it 
    257                                will re-direct the request there. 
     271        sessCookie:            session cookie returned from call to connect()  
     272                               for a browser client.  Input as a string or 
     273                               SimpleCookie type. 
    258274        proxyCert:             proxy certificate - use as ID instead of  
    259                                session ID + encrSessMgrWSDLuri in the case of 
    260                                command line client. 
    261         smWSDL:                WSDL URI for Session Manager WS call this may 
    262                                not be the same as the encrypted address in 
    263                                encrSessMgrWSDLuri.  If set a new Service 
    264                                Proxy will be set up. 
     275                               a cookie in the case of a command line client. 
     276        aaWSDL:                WSDL URI for Attribute Authority WS. 
    265277        reqRole:               The required role for access to a data set. 
    266278                               This can be left out in which case the  
     
    279291                               get Attribute Certificates for making a mapped 
    280292                               AC 
    281         encrCert:              A public key for the client to enable the 
    282                                Session Manager to encrypt its reply to this 
    283                                call 
    284293        """ 
    285             
    286         if smWSDL: 
    287             # Instantiate WS proxy 
    288             self.serviceProxy(smWSDL) 
    289              
    290         if smEncrPubKeyFilePath: 
    291             self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
    292      
     294 
     295        if sessCookie and isinstance(sessCookie, basestring): 
     296            try: 
     297                sessCookie = SimpleCookie(sessCookie) 
     298            except Exception, e: 
     299                raise SessionClientError("Error parsing session cookie: " + \ 
     300                                         str(e)) 
    293301             
    294302        # Make authorisation request 
    295303        try: 
    296             authReq=AuthorisationReq(aaWSDL=aaWSDL, 
    297                              sessID=sessID, 
    298                              encrSessMgrWSDLuri=encrSessMgrWSDLuri, 
     304            authReq = AuthorisationReq(aaWSDL=aaWSDL, 
     305                             sessID=sessCookie['NDG-ID1'].value,  
     306                             encrSessMgrWSDLuri=sessCookie['NDG-ID2'].value, 
     307                             encrSessMgrPubKeyURI=sessCookie['NDG-ID3'].value, 
    299308                             proxyCert=proxyCert, 
    300309                             reqRole=reqRole, 
     
    303312                             extAttCertList=extAttCertList, 
    304313                             extTrustedHostList=extTrustedHostList, 
    305                              encrCert=encrCert, 
    306                              encrPubKeyFilePath=self.__smEncrPubKeyFilePath)  
     314                             encrCert=self.__clntPubKeyFilePath, 
     315                             encrPubKeyFilePath=self.__smPubKeyFilePath)  
    307316                                             
    308317            resp = self.__smSrv.reqAuthorisation(authorisationReq=authReq()) 
     
    332341         
    333342        # Public key of session manager used to encrypt requests 
    334         smEncrPubKeyFilePath = None#'../certs/badc-sm-cert.pem' 
     343        smPubKeyFilePath = None#'../certs/badc-sm-cert.pem' 
    335344         
    336345        userName = 'pjkbodc'#'pjkersha' 
    337346 
    338347        sessClnt = SessionClient(smWSDL=smWSDL, 
    339                                  smEncrPubKeyFilePath=smEncrPubKeyFilePath, 
     348                                 smPubKeyFilePath=smPubKeyFilePath, 
    340349                                 traceFile=sys.stderr) 
    341350         
  • TI12-security/trunk/python/NDG/SessionMgrIO.py

    r662 r686  
    228228    xmlTagTmpl = {  "sessID":                 "", 
    229229                    "encrSessMgrWSDLuri":     "", 
     230                    "encrSessMgrPubKeyURI":   "", 
    230231                    "proxyCert":              "", 
    231232                    "aaWSDL":                 "", 
     
    252253                                
    253254        # Check for encrypted text or valid credentials 
    254         if 'sessID' not in self and 'encrSessMgrWSDLuri' not in self: 
     255        if 'sessID' not in self and \ 
     256           'encrSessMgrWSDLuri' not in self and \ 
     257           'encrSessMgrPubKeyURI' not in self: 
    255258            if 'proxyCert' not in self: 
    256259                raise AuthorisationReqError(\ 
    257                 "Authorisation request must include the credentials: " + \ 
    258                 "\"sessID\" and \"encrSessMgrWSDLuri\" or " + \ 
    259                 "\"proxyCert\"") 
     260                    "Authorisation request must include the credentials: " + \ 
     261                    "\"sessID\", \"encrSessMgrWSDLuri\" and " + \ 
     262                    "\"encrSessMgrPubKeyURI\" or \"proxyCert\"") 
    260263                 
    261264        if 'aaWSDL' not in self:             
  • TI12-security/trunk/python/NDG/X509.py

    r518 r686  
    243243 
    244244        # Return as X500DN type 
    245         return X500DN(self.__m2CryptoX509.get_subject()) 
     245        return X500DN(m2CryptoX509Name=self.__m2CryptoX509.get_subject()) 
    246246     
    247247    subject = property(fget=__getSubject,  doc="Certificate subject") 
  • TI12-security/trunk/python/NDG/XMLMsg.py

    r544 r686  
    120120                            
    121121            except Exception, e: 
    122                 raise XMLMsgError("Error decrypting credentials: %s" % e)      
     122                raise XMLMsgError("Error decrypting input text: %s" % e)      
    123123 
    124124            # Parse elements from decrypted result saving as dictionary 
     
    129129            if xmlTxt: 
    130130                # Input XML text set - parse tags into dictionary self.__xmlTags 
    131                 self.parseXML()                 
     131                try: 
     132                    self.parseXML() 
     133                except: 
     134                    # May have failed because text was encrypted - try  
     135                    # decrypting if a private key is available 
     136                    try: 
     137                        self.__xmlSecDoc.decrypt(xmlTxt=xmlTxt, 
     138                                                 encrPriKeyPwd=encrPriKeyPwd) 
     139                                               
     140                        self.__xmlTxt = str(self.__xmlSecDoc) 
     141                    except: 
     142                        raise XMLMsgError("Error parsing text")                 
    132143            else: 
    133144                # XML text will be set from tags set as keywords 
  • TI12-security/trunk/python/SessionMgrServer.py

    r667 r686  
    9494    pass-phrase must be set in the 'dbURI' tag in the configuration file. 
    9595     
    96 [-w | --nowsdlencrkey] 
    97     skip the prompt for the WSDL encryption key and pick up the key from the  
    98     'sessMgrWSDLkey' tag in the configuration file. 
     96[-w | --noencrkey] 
     97    skip the prompt for the encryption key and pick up the key from the  
     98    'sessMgrEncrKey' tag in the configuration file. 
    9999""") 
    100100 
     
    108108                         "debug",  
    109109                         "nopassphrase", 
    110                          "nowsdlencrkey"] 
     110                         "noencrkey"] 
    111111        opts, args = getopt.getopt(sys.argv[1:], "hf:p:dnw", optLongNames) 
    112112 
     
    140140            noPPhrase = True 
    141141 
    142         elif opt in ("-w", "--nowsdlencrkey"): 
     142        elif opt in ("-w", "--noencrkey"): 
    143143            noWSDLencrKey = True 
    144144 
     
    173173        import getpass 
    174174        try: 
    175             sessMgrWSDLkey = getpass.getpass(prompt="WSDL Encryption Key: ") 
     175            sessMgrEncrKey = getpass.getpass(prompt="WSDL Encryption Key: ") 
    176176        except KeyboardInterrupt: 
    177177            sys.exit(1) 
    178178    else: 
    179         sessMgrWSDLkey = None 
     179        sessMgrEncrKey = None 
    180180 
    181181 
     
    186186        sm = SessionMgr(propFilePath, 
    187187                        credReposPPhrase=credReposPPhrase, 
    188                         sessMgrWSDLkey=sessMgrWSDLkey) 
     188                        sessMgrEncrKey=sessMgrEncrKey) 
    189189 
    190190    except Exception, e: 
  • TI12-security/trunk/python/ndgSessionClient.py

    r674 r686  
    1616import sys 
    1717import os 
    18 import getopt 
     18import optparse 
    1919import re 
    2020 
     21from Cookie import SimpleCookie 
     22 
    2123from NDG.SessionClient import * 
    2224 
    2325 
    2426#_____________________________________________________________________________ 
    25 def usage(fp=sys.stdout): 
    26     """Describes how to call session client from the command line""" 
    27     progName = os.path.basename(sys.argv[0]) 
    28      
    29     fp.write(\ 
    30     """usage: %s [--add-user|--connect|--req-autho]|[--connect --req-autho] 
    31         [<args...>]%s""" % (progName, os.linesep)) 
    32          
    33     fp.write("""     
    34 -h | --help 
    35     print usage summary 
    36  
    37 Web-service calls: 
    38      
    39 -n | --add-user 
    40     add a new user:  
    41          
    42     %s --add-user -u <username> [-p] -s <Session Manager WSDL URI> 
    43  
    44 -c | --connect 
    45     login in to a Session Manager 
    46      
    47     %s --connect -u <username> [-p] -s <Session Manager WSDL URI> 
    48      
    49 -r | --req-autho 
    50     Get a Session Manager to request authorisation from an Attribute  
    51     Authority on behalf of a user:  
    52      
    53     %s --req-autho -i <User's Session ID> -s <Session Manager WSDL URI>  
    54     -a <Attribute Authority WSDL URI> [-m -q <role name> -l -f <file path> 
    55     -t <file path>] 
    56    
    57 Generic options: 
    58      
    59 -s <Session Manager WSDL URI> |  
    60  --session-mgr-wsdl-uri=<Session Manager WSDL URI> 
    61     Address of Session Manager to connect to. 
     27def setSoapDebug(option, optStr, value, parser): 
     28    """Callback function for parser""" 
     29    parser.values.soapDebug = sys.stderr 
     30 
     31    
     32#_____________________________________________________________________________ 
     33def setSessCookie(option, optStr, value, parser): 
     34    """Callback function for parser""" 
     35    try: 
     36        parser.values.sessCookie = SimpleCookie(open(value).read().strip()) 
     37    except IOError, (errNo, errMsg): 
     38        raise optparse.OptionValueError(\ 
     39                    "Reading cookie from file \"%s\": %s" % (value, errMsg)) 
     40         
     41    except Exception, e: 
     42        raise optparse.OptionValueError(\ 
     43                    "Reading cookie from file \"%s\": %s" % (value, str(e))) 
    6244       
    63 -d  | --soap-debug 
    64     Print SOAP message output. 
    65  
    66 Options specific to --connect and --add-user: 
    67      
    68 -u <username> | --username=<username> 
    69     username for --connect call 
    70  
    71 -p | --pass-phrase-from-stdin 
    72     Take user's pass-phrase from stdin.  If this flag is omitted, pass-phrase  
    73     is prompted for. 
    74  
    75 Options specific to --req-autho: 
    76      
    77 -i <session ID> | --sessionID=<Session ID> 
    78     Session ID for --req-autho call.  Session ID is obtained from the cookie 
    79     returned from previous call to "%s --connect ..." 
    80      
    81 -e <encrypted Session Manager WSDL URI> |  
    82  --encr-sess-mgr-wsdl-uri <encrypted Session Manager WSDL URI> 
    83     Encrypted address of Session Manager where user session is held.  This is 
    84     obtained from the cookie returned from call to "%s --connect ..." 
    85      
    86 -a <Attribute Authority WSDL URI> |  
    87  --att-authority-wsdl-uri=<Attribute Authority WSDL URI> 
    88     The address of the Attribute Authority from which to request an  
    89     Attribute Certificate. 
    90  
    91 -m | --map-from-trusted-hosts 
    92     Set to allow the Session Manager to automatically use Attribute  
    93     Certificates from the user's wallet or if no suitable ones are found, 
    94     to contact other trusted hosts in order to get Attribute Certificates 
    95     for mapping. 
    96      
    97 -q <role name> | --req-role=<role name> 
    98     Give a hint to the authorisation request as to what role is needed in  
    99     order to get a mapped Attribute Certificate back from the Attribute  
    100     Authority. 
    101      
    102 -l | --rtn-ext-att-cert-list 
    103     Determines behaviour for where authorisation is denied by an Attribute 
    104     Authority.   If set, a list of candidate Attribute Certificates from 
    105     trusted import hosts will be returned.  Any one of these could be 
    106     re-input in a subsequent with the --ext-att-cert-list-file option in order 
    107     to get a mapped Attribute Certificate 
    108      
    109 -f <file path> | --ext-att-cert-list-file=<file path> 
    110     file of concatenated Attribute Certificates.  These are certificates 
    111     from other import hosts trusted by the Attribute Authority.  The Session 
    112     Manager tries each in turn until the Attribute Authority accepts one  
    113     and uses it to create and return a mapped Attribute Certificate. 
    114      
    115 -t | --ext-trusted-host-file=<comma separated variable file> 
    116     For use with --req-autho flag.  Pass a file containing a list of hosts 
    117     trusted by the Attribute Authority.  The Session Manager will contact  
    118     these hosts in turn until it can get an Attribute Certificate to pass 
    119     to the Attribute Authority to get a mapped Attribute Certificate in  
    120     return. 
    121 """ % (progName, progName, progName, progName, progName)) 
    122  
    123  
    12445#_____________________________________________________________________________ 
    12546if __name__ == '__main__': 
    12647 
    127     try: 
    128         optLongNames = [ "help", 
    129                          "add-user",  
    130                          "connect", 
    131                          "req-autho", 
    132                          "session-mgr-wsdl-uri=",  
    133                          "att-authority-wsdl-uri=", 
    134                          "username=", 
    135                          "pass-phrase-from-stdin", 
    136                          "session-id=", 
    137                          "encr-sess-mgr-wsdl-uri", 
    138                          "soap-debug", 
    139                          "map-from-trusted-hosts", 
    140                          "req-role=", 
    141                          "rtn-ext-att-cert-list", 
    142                          "ext-att-cert-list-file=", 
    143                          "ext-trusted-host-file="] 
    144         optShortNames = "hncrs:a:u:pi:e:dmq:lf:t:" 
    145         opts, args = getopt.getopt(sys.argv[1:], optShortNames, optLongNames) 
    146  
    147     except getopt.GetoptError, e: 
    148         sys.stderr.write("Error: %s\n\n" % e) 
    149         usage(fp=sys.stderr) 
    150         sys.exit(1) 
    151  
    152     # Use long options to make a dictionary 
    153     argDict = {}.fromkeys([opt.split('=')[0] for opt in optLongNames]) 
     48    usage = os.path.basename(sys.argv[0]) + " [--add-user=<username> ...]|"+\ 
     49            "[--connect=<username> ...]|[--req-autho ...]|" + \ 
     50            "[--connect=<username> ... --req-autho ...]" 
     51             
     52    parser = optparse.OptionParser(usage=usage) 
     53    parser.add_option("-n",  
     54                      "--add-user",  
     55                      dest="newUserName", 
     56                      help="add a new user, see also: -p and -s options") 
     57 
     58    parser.add_option("-c",  
     59                      "--connect", 
     60                      dest="userName", 
     61                      help="""\ 
     62login in to a Session Manager with username, see also: -u, -p, -x, -y and -s 
     63options""") 
    15464     
    155     extTrustedHostList = None 
    156     extAttCertList = None 
     65    parser.add_option("-r",  
     66                      "--req-autho",  
     67                      action="store_true", 
     68                      dest="reqAuthorisation",  
     69                      default=False,  
     70                      help=\ 
     71"""Get a Session Manager to request authorisation from an Attribute Authority  
     72on behalf of a user; see also: -i, -s, -a, -x, -y [, -t]""") 
     73 
     74    parser.add_option("-y", 
     75                      "--clnt-cert-file", 
     76                      dest="clntCertFile", 
     77                      help=\ 
     78"""X.509 Certificate of client.  This is used by the Session Manager to  
     79encrypt responses.  WARNING: If this is not set, the response will be sent  
     80back in clear text""") 
     81 
     82    parser.add_option("-x", 
     83                      "--session-mgr-cert-file", 
     84                      dest="smPubKeyFilePath", 
     85                      help=\ 
     86"""X.509 Certificate of Session Manager.  This is used to encrypt the request 
     87to the Session Manager.  WARNING: If this is not set, the request will be sent  
     88back in clear text""") 
     89 
     90    parser.add_option("-s", 
     91                      "--session-mgr-wsdl-uri", 
     92                      dest="sessMgrWSDLuri", 
     93                      help="Address of Session Manager to connect to") 
     94 
     95    parser.add_option("-d", 
     96                      "--soap-debug", 
     97                      dest="soapDebug", 
     98                      action="callback", 
     99                      callback=setSoapDebug, 
     100                      help="Print SOAP message output") 
     101 
     102    parser.add_option("-p", 
     103                      "--pass-phrase-from-stdin", 
     104                      action="store_true", 
     105                      dest="bPassPhraseFromStdin", 
     106                      default=False, 
     107                      help="""\ 
     108Take user's pass-phrase from stdin.  If this flag is omitted, pass-phrase is 
     109prompted for from tty""") 
     110 
     111    parser.add_option("-i", 
     112                      "--cookie-file", 
     113                      action="callback", 
     114                      callback=setSessCookie, 
     115                      type="string", 
     116                      dest="sessCookie", 
     117                      help=\ 
     118"""Session cookie for --req-autho/-r call.  This is returned from a previous 
     119connect call (-c USERNAME/--connect=USERNAME).  Note that connect and request 
     120authoirsatino calls can be combined.  In this case, this arg is not needed as 
     121the cookie is passed directly from the connect call output to the 
     122authorisation request e.g. ... -c username -r -s "http://..." -a 
     123"http://...""") 
     124 
     125    parser.add_option("-e", 
     126                      "--pass-cookie-from-stdin", 
     127                      action="store_true", 
     128                      dest="bCookieFromStdin", 
     129                      default=False, 
     130                      help="Take session cookie from stdin.") 
     131 
     132    parser.add_option("-a", 
     133                      "--att-authority-wsdl-uri", 
     134                      dest="attAuthorityWSDLuri", 
     135                      help="""\ 
     136For use with --req-autho/-r flag.  The address of the Attribute Authority from 
     137which to request an Attribute Certificate.""") 
     138 
     139    parser.add_option("-m", 
     140                      "--map-from-trusted-hosts", 
     141                      action="store_true", 
     142                      dest="mapFromTrustedHosts", 
     143                      default=False, 
     144                      help=\ 
     145"""For use with --req-autho/-r flag.  Set to allow the Session Manager to 
     146automatically use Attribute Certificates from the user's wallet or, if no 
     147suitable ones are found, to contact other trusted hosts in order to get 
     148Attribute Certificates for mapping""") 
     149 
     150    parser.add_option("-q", 
     151                      "--req-role", 
     152                      dest="reqRole", 
     153                      help="""\ 
     154For use with --req-autho/-r flag.  Give a hint to the authorisation request as 
     155to what role is needed in order to get a mapped Attribute Certificate back 
     156from the Attribute Authority""") 
     157 
     158    parser.add_option("-l", 
     159                      "--rtn-ext-att-cert-list", 
     160                      action="store_true", 
     161                      dest="rtnExtAttCertList", 
     162                      default=False, 
     163                      help=\ 
     164"""For use with --req-autho/-r flag.  Determines behaviour in the case where  
     165authorisation is denied by an Attribute Authority.  If set, a list of 
     166candidate Attribute Certificates from trusted hosts will be returned.  Any one 
     167of these could be re-input in a subsequent authorisation request by setting 
     168the --ext-att-cert-list-file option.  The certificates can be used to obtain a 
     169mapped Attribute Certificate from the import target Attribute Authority""") 
     170 
     171    parser.add_option("-f", 
     172                      "--ext-att-cert-list-file", 
     173                      dest="extAttCertListFile", 
     174                      help=\ 
     175"""For use with --req-autho/-r flag.  A file of concatenated Attribute 
     176Certificates.  These are certificates from other import hosts trusted by the 
     177Attribute Authority.  The Session Manager tries each in turn until the 
     178Attribute Authority accepts one and uses it to create and return a mapped 
     179Attribute Certificate""") 
     180     
     181    parser.add_option("-t", 
     182                      "--ext-trusted-hosts-file", 
     183                      dest="extTrustedHostsFile", 
     184                      help=\ 
     185"""For use with --req-autho/-r flag.  Pass a file containing a comma  
     186separarated list of hosts that are trusted by the Attribute Authority.  The 
     187Session Manager will contact these hosts in turn, stopping when one of them 
     188grants it an Attribute Certificate that it can present to the target Attribute 
     189Authority in order to get a mapped Attribute Certificate in return.""") 
     190 
     191    (options, args) = parser.parse_args() 
     192 
     193 
    157194    passPhrase = None 
    158      
    159     for opt, arg in opts: 
    160         if opt in ("-h", "--help"): 
    161             usage() 
    162             sys.exit(0) 
    163  
    164         elif opt in ("-n", "--add-user"): 
    165             argDict['add-user'] = True 
    166  
    167         elif opt in ("-c", "--connect"): 
    168             argDict['connect'] = True 
    169  
    170         elif opt in ("-r", "--req-autho"): 
    171             argDict['req-autho'] = True 
    172  
    173         elif opt in ("-s", "--session-mgr-wsdl-uri"): 
    174             argDict['session-mgr-wsdl-uri'] = arg 
    175  
    176         elif opt in ("-a", "--att-authority-wsdl-uri"): 
    177             argDict['att-authority-wsdl-uri'] = arg 
    178  
    179         elif opt in ("-u", "--username"): 
    180             argDict['username'] = arg 
    181  
    182         elif opt in ("-p", "--pass-phrase-from-stdin"): 
    183             argDict['pass-phrase-from-stdin'] = True 
    184  
    185         elif opt in ("-i", "--session-id"): 
    186             argDict['session-id'] = arg 
    187  
    188         elif opt in ("-e", "--encr-sess-mgr-wsdl-uri"): 
    189             argDict['encr-sess-mgr-wsdl-uri'] = arg 
    190  
    191         elif opt in ("-d", "--soap-debug"): 
    192             argDict['soap-debug'] = sys.stderr 
    193  
    194         elif opt in ("-m", "--map-from-trusted-hosts"): 
    195             argDict['map-from-trusted-hosts'] = True 
    196                  
    197         elif opt in ("-q", "--req-role"): 
    198             argDict['req-role'] = arg 
    199          
    200         elif opt in ("-l", "--rtn-ext-att-cert-list"): 
    201             argDict['rtn-ext-att-cert-list'] = True 
    202              
    203         elif opt in ("-f", "--ext-att-cert-list-file"): 
    204             argDict['ext-att-cert-list-file'] = arg 
    205              
    206             try: 
    207                 # Open and read file removing any <?xml ... ?> headers 
    208                 fpExtAttCertList = open(argDict['ext-att-cert-list-file']) 
    209                 sAttCertList = \ 
    210                      re.sub("\s*<\?xml.*\?>\s*", "", fpExtAttCertList.read()) 
    211                  
    212                 # Convert into a list 
    213                 extAttCertList = ['<attributeCertificate>' + ac for ac in \ 
    214                             sAttCertList.split('<attributeCertificate>')[1:]] 
    215             except Exception, e: 
    216                 sys.stderr.write(\ 
    217                     "Error parsing file \%s\" for option \"%s\": %s" % \ 
    218                     (arg, opt, str(e))) 
    219              
    220         elif opt in ("-t", "ext-trusted-host-file"): 
    221             try: 
    222                 extTrustedHostList = \ 
    223                     re.split("\s*,\s*", 
    224                              open(argDict['ext-trusted-host-file']).read()) 
    225                  
    226             except Exception, e: 
    227                 sys.stderr.write(\ 
    228                     "Error parsing file \%s\" for option \"%s\": %s" % \ 
    229                     (arg, opt, str(e))) 
    230                      
    231         else: 
    232             sys.stderr.write("Option not recognised: %s\n\n" % opt) 
    233             usage(fp=sys.stderr) 
    234             sys.exit(1) 
    235  
    236  
     195    
    237196    # For connect/addUser a pass-phrase is needed 
    238     if argDict['add-user'] or argDict['connect']: 
    239          
    240         if argDict['pass-phrase-from-stdin']: 
     197    if options.newUserName or options.userName: 
     198         
     199        if options.bPassPhraseFromStdin: 
    241200            # Read from standard input 
    242201            passPhrase = sys.stdin.read().strip() 
     
    246205            import getpass 
    247206            try: 
    248 #                passPhrase = getpass.getpass(prompt="pass-phrase: ")  
    249                 passPhrase = open('./Tests/tmp').read().strip() 
     207                passPhrase = getpass.getpass(prompt="pass-phrase: ")  
    250208            except KeyboardInterrupt: 
    251209                sys.exit(1) 
    252210 
     211                
     212    extAttCertList = None 
     213                 
     214    if options.extAttCertListFile: 
     215        try: 
     216            # Open and read file removing any <?xml ... ?> headers 
     217            sExtAttCertListFile = open(options.extAttCertListFile).read() 
     218            sAttCertTmp = re.sub("\s*<\?xml.*\?>\s*", "", sExtAttCertListFile) 
     219             
     220            # Convert into a list 
     221            extAttCertList = ['<attributeCertificate>' + ac for ac in \ 
     222                            sAttCertTmp.split('<attributeCertificate>')[1:]] 
     223        except Exception, e: 
     224            sys.stderr.write(\ 
     225                "Error parsing file \%s\" for option \"%s\": %s" % \ 
     226                (arg, "--ext-att-cert-list-file\"/\"-f", str(e))) 
     227 
     228         
     229    extTrustedHostList = None 
     230 
     231    if options.extTrustedHostsFile: 
     232        try: 
     233            extTrustedHostList = \ 
     234                re.split("\s*,\s*", open(options.extTrustedHostsFile).read()) 
     235             
     236        except Exception, e: 
     237            sys.stderr.write(\ 
     238                "Error parsing file \%s\" for option \"%s\": %s" % \ 
     239                (arg, "--ext-trusted-host-file\"/\"-t", str(e))) 
     240 
     241#    import pdb 
     242#    pdb.set_trace() 
    253243 
    254244    # Initialise session client 
    255245    try: 
    256         sessClnt = SessionClient(smWSDL=argDict['session-mgr-wsdl-uri'], 
    257                                  traceFile=argDict['soap-debug']) 
     246        sessClnt = SessionClient(smWSDL=options.sessMgrWSDLuri, 
     247                                 smPubKeyFilePath=options.smPubKeyFilePath, 
     248                                 clntPubKeyFilePath=options.clntCertFile, 
     249                                 traceFile=options.soapDebug) 
    258250    except Exception, e: 
    259251        sys.stderr.write("Initialising client: %s\n" % str(e)) 
    260252        sys.exit(1) 
    261          
     253     
     254    methodCall = False     
    262255    try: 
    263         if argDict['add-user']: 
    264             sessClnt.addUser(userName=argDict['username'], pPhrase=passPhrase) 
     256        if options.newUserName: 
     257            methodCall = True 
     258             
     259            sessClnt.addUser(userName=options.newUserName, pPhrase=passPhrase) 
    265260            sys.exit(0) 
    266261                             
    267         if argDict['connect']: 
    268             sSessCookie = sessClnt.connect(userName=argDict['username'],  
     262        if options.userName: 
     263            methodCall = True 
     264             
     265            sSessCookie = sessClnt.connect(userName=options.userName,  
    269266                                           pPhrase=passPhrase)             
    270267            print sSessCookie 
    271268            # Don't exit here - req-autho may have been set too 
    272      
    273         if argDict['req-autho']: 
    274             if argDict['connect']: 
     269             
     270        if options.reqAuthorisation: 
     271            methodCall = True 
     272 
     273            if options.userName: 
    275274                # Connect was set also - parse cookie in order to session ID 
    276275                # and WSDL address 
    277                 from Cookie import SimpleCookie 
    278                 sessCookie = SimpleCookie(sSessCookie) 
    279                  
    280                 argDict['session-id'] = sessCookie['NDG-ID1'].value 
    281                 argDict['encr-sess-mgr-wsdl-uri']=sessCookie['NDG-ID2'].value 
     276                options.sessCookie = SimpleCookie(sSessCookie) 
    282277                 
    283278            authResp = sessClnt.reqAuthorisation(\ 
    284                         sessID=argDict['session-id'],  
    285                         encrSessMgrWSDLuri=argDict['encr-sess-mgr-wsdl-uri'], 
    286                         aaWSDL=argDict['att-authority-wsdl-uri'], 
    287                         mapFromTrustedHosts=argDict['map-from-trusted-hosts'], 
    288                         reqRole=argDict['req-role'], 
    289                         rtnExtAttCertList=argDict['rtn-ext-att-cert-list'], 
    290                         extAttCertList=extAttCertList, 
    291                         extTrustedHostList=extTrustedHostList) 
     279                            sessCookie=options.sessCookie, 
     280                            aaWSDL=options.attAuthorityWSDLuri, 
     281                            mapFromTrustedHosts=options.mapFromTrustedHosts, 
     282                            reqRole=options.reqRole, 
     283                            rtnExtAttCertList=options.rtnExtAttCertList, 
     284                            extAttCertList=extAttCertList, 
     285                            extTrustedHostList=extTrustedHostList) 
    292286            print authResp 
    293         else:    
    294             sys.stderr.write(\ 
    295             "Set a flag to specify the web-service call e.g. --connect\n\n") 
    296             usage(fp=sys.stderr) 
     287         
     288 
     289        if not methodCall:    
     290            sys.stderr.write("Set a flag to specify the web-service call " + \ 
     291                             "e.g. --connect=USERNAME\n\n") 
     292            parser.print_help() 
    297293            sys.exit(1) 
    298294             
  • TI12-security/trunk/python/sessionMgrProperties.xml

    r668 r686  
    55    <keyFile></keyFile> 
    66    <keyPPhrase></keyPPhrase> 
    7     <sessMgrWSDLkey></sessMgrWSDLkey> 
    8     <sessMgrWSDLuri></sessMgrWSDLuri> 
     7    <sessionMgrEncrKey></sessionMgrEncrKey> 
     8    <sessionMgrWSDLuri></sessionMgrWSDLuri> 
     9    <sessionMgrPubKeyURI></sessionMgrPubKeyURI> 
    910    <cookieDomain></cookieDomain> 
    1011    <myProxyProp> 
Note: See TracChangeset for help on using the changeset viewer.