Changeset 539


Ignore:
Timestamp:
27/01/06 18:27:10 (14 years ago)
Author:
pjkersha
Message:

AttAuthority?.py: authorise method - proxyCertTxt -> proxyCert for
simplicity. Return attCert as AttCert? instance.

AttAuthorityIO.py: s

AttCert?

AttCert?.py:

  • default validity time is now 8 hours
  • corrected filePath refs in parse method

CredWallet?.py:

  • Added caCertFilePath property()
  • also, clntCertFilePath - cert used by AA to encrypt authorisation resp.

Session.py: noEncrypt keyword no longer needed in SessionMgr?.connect()
ConnectReq? and ConnectResp? handling.

SessionClient?.py:

  • full path for WSDL URIs
  • fixed reqAuthorisation resp handling.

SessionMgrIO.py: noEncrypt keyword no longer needed.

XMLSecDoc.py: added option to asString() to allow xml header to be
stripped out.

attAuthority_services_server.py: mods to resp formatting.

Location:
security/trunk/python/NDG
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • security/trunk/python/NDG/AttAuthority.py

    r533 r539  
    190190        """Request a new Attribute Certificate for authorisation 
    191191 
    192         proxyCertFilePath|proxyCertTxt: 
     192        proxyCertFilePath|proxyCert: 
    193193 
    194194                                user's proxy certificate use appropriate 
     
    196196                                text content respectively. 
    197197                                 
    198                                 Nb. proxyCertTxt is set via reqKeys 
     198                                Nb. proxyCert is set via reqKeys 
    199199                                 
    200200        userAttCertFilePath|userAttCertTxt: 
     
    223223                reqKeys = AuthorisationReq(encrXMLtxt=reqXMLtxt, 
    224224                                    encrPriKeyFilePath=self.__prop['keyFile'], 
    225                                     encrPriKeyPwd=self.__prop['keyPPhrase']) 
     225                                    encrPriKeyPwd=self.__prop['keyPwd']) 
    226226            except Exception, e: 
    227227                 
     
    246246                usrProxyCert.read(proxyCertFilePath) 
    247247                 
    248             elif reqKeys['proxyCertTxt'] is not None: 
     248            elif reqKeys['proxyCert'] is not None: 
    249249 
    250250                # Proxy Certificate input as string text 
    251                 usrProxyCert.parse(reqKeys['proxyCertTxt']) 
     251                usrProxyCert.parse(reqKeys['proxyCert']) 
    252252 
    253253            else: 
     
    430430            attCert.write() 
    431431 
    432             # Return the text to caller 
    433             return attCert.asString() 
     432            # Return the cert to caller 
     433            return attCert 
    434434         
    435435        except Exception, e: 
  • security/trunk/python/NDG/AttAuthorityIO.py

    r535 r539  
    1616from XMLMsg import * 
    1717 
     18# For use with AuthorisationResp class 
     19from AttCert import * 
     20 
    1821#_____________________________________________________________________________ 
    1922class AuthorisationReqError(XMLMsgError):     
     
    3134     
    3235    # Override base class class variables 
    33     xmlTagTmpl = {  "proxyCertTxt":    "", 
    34                     "userAttCertTxt":  ""    } 
     36    xmlTagTmpl = {  "proxyCert":    "", 
     37                    "userAttCert":  "", 
     38                    "clntCert":     ""    } 
    3539                     
    3640    xmlMandTags = ["proxyCert"] 
     
    5155     
    5256    # Override base class class variables 
    53     xmlTagTmpl = {  "attCert":           "", 
     57    xmlTagTmpl = {  "credential":        "", 
    5458                    "statCode":          "", 
    5559                    "errMsg":            ""    } 
    5660 
    57     xmlMandTags = ["errMsg", "statCode"] 
     61    xmlMandTags = ["statCode"] 
    5862     
    5963    accessGranted = 'AccessGranted'     
     
    6266 
    6367 
    64     def __init__(self, noEncrypt=True, **xmlMsgKeys): 
     68    def __init__(self, **xmlMsgKeys): 
    6569        """XML for receiving output from Attribute Authority authorisation  
    6670        call 
     
    6973                       input as keywords then 'errMsg' or 'statCode'  
    7074                       must be set. 
    71                          
    72                        Note: noEncrypt=True must be set otherwise an 
    73                        exception will be raised. 
    7475        """         
    7576         
    76         # Allow user credentials to be access like dictionary keys 
    77         super(self.__class__, self).__init__(noEncrypt=True, **xmlMsgKeys) 
     77        # Allow credentials to be accessed like dictionary keys 
     78        super(self.__class__, self).__init__(**xmlMsgKeys) 
    7879         
     80        if 'credential' not in self and 'errMsg' not in self: 
     81            raise AuthorisationRespError(\ 
     82                                'Expecting "credential" or "errMsg" keywords') 
     83 
     84    #_________________________________________________________________________ 
     85    def updateXML(self, **xmlTags): 
     86        """Override base class implementation to include extra code 
     87        to allow attribute certificate to be set from a string or AttCert 
     88        type""" 
     89         
     90        # Update dictionary 
     91        self.update(**xmlTags) 
     92         
     93        # Create XML formatted string ready for encryption 
     94        try: 
     95            rootNode = ElementTree.Element(self.__class__.__name__) 
     96            rootNode.tail = os.linesep 
     97             
     98            for tag in xmlTags: 
     99                # ElementTree tostring doesn't like bool types 
     100                elem = ElementTree.SubElement(rootNode, tag) 
     101                elem.tail = os.linesep 
     102                 
     103                if isinstance(self[tag], bool): 
     104                    elem.text = "%d" % self[tag] 
     105                 
     106                elif tag == 'credential': 
     107 
     108                    # str() will convert self[tag] correctly if it is an 
     109                    # AttCert type  
     110                    attCertElem = ElementTree.XML(str(self[tag])) 
     111                    attCertElem.tail = os.linesep 
     112                    elem.append(attCertElem) 
     113                else:         
     114                    elem.text = self[tag] 
     115                      
     116            self.xmlTxt = self.xmlHdr + os.linesep + \ 
     117                                                ElementTree.tostring(rootNode) 
     118        except Exception, e: 
     119            raise XMLMsgError("Creating XML: %s" % e) 
     120 
     121 
     122    #_________________________________________________________________________ 
     123    def parseXML(self): 
     124        """Override base class implementation to include extra code 
     125        to parse extAttCertList tag""" 
     126         
     127        rootElem = super(self.__class__, self).parseXML(rtnRootElem=True) 
     128        if 'credential' in self: 
     129 
     130            # Convert attribute certificate to AttCert instance 
     131            try: 
     132                self['credential'] = AttCertParse(self['credential']) 
     133                 
     134            except Exception, e: 
     135                raise AuthorisationRespError(\ 
     136                    "Error parsing Attribute Certificate: " + str(e))   
     137 
    79138 
    80139#_____________________________________________________________________________ 
     
    118177 
    119178 
    120     def __init__(self, noEncrypt=True, **xmlMsgKeys): 
     179    def __init__(self, **xmlMsgKeys): 
    121180        """XML for receiving output from Attribute Authority authorisation  
    122181        call 
     
    125184                       input as keywords then 'errMsg' or 'statCode'  
    126185                       must be set. 
    127                          
    128                        Note: noEncrypt=True must be set otherwise an 
    129                        exception will be raised. 
    130186        """         
    131187         
    132188        # Allow user credentials to be access like dictionary keys 
    133         super(self.__class__, self).__init__(noEncrypt=True, **xmlMsgKeys) 
     189        super(self.__class__, self).__init__(**xmlMsgKeys) 
  • security/trunk/python/NDG/AttCert.py

    r531 r539  
    9898        # to one day 
    9999        if lifeTime is -1: 
    100             self.__lifeTime = 86400 # 1 day 
     100            self.__lifeTime = 28800 # 8 hours 
    101101        else: 
    102102            self.__lifeTime = lifeTime 
     
    117117        "Attribute Certificate keys cannot be removed" 
    118118         
    119         raise AttCertError('Keys cannot be deleted from ' + self.__class__.__name__) 
     119        raise AttCertError('Keys cannot be deleted from ' + \ 
     120                           self.__class__.__name__) 
    120121 
    121122 
     
    448449         
    449450        if not acInfoElem: 
    450             raise AttCertError("<acInfo> tag not found in \""+filePath+"\"") 
     451            raise AttCertError("<acInfo> tag not found in \"%s\"" % \ 
     452                               self.filePath) 
    451453 
    452454 
     
    484486        if self.__dat['validity']['notBefore'] is None: 
    485487            raise AttCertError("<notBefore> tag not found in \"%s\"" % \ 
    486                                filePath) 
     488                               self.filePath) 
    487489 
    488490        # Update datetime object equivalent 
     
    495497         
    496498        if self.__dat['validity']['notAfter'] is None: 
    497             raise AttCertError("<notAfter> tag not found in \"%s\""%filePath) 
     499            raise AttCertError("<notAfter> tag not found in \"%s\"" % 
     500                               self.filePath) 
    498501 
    499502 
     
    506509        roleElem = acInfoElem.findall("attributes/roleSet/role/name") 
    507510        if roleElem is None: 
    508             raise AttCertError("<role> tag not found in \"" + filePath + \ 
    509                                 "\"") 
     511            raise AttCertError("<role> tag not found in \"%s\"" % \ 
     512                               self.filePath) 
    510513         
    511514        self.__dat['attributes']['roleSet'] = \ 
  • security/trunk/python/NDG/CredWallet.py

    r533 r539  
    130130                 proxyCertTxt, 
    131131                 caCertFilePath=None, 
     132                 clntCertFilePath=None, 
    132133                 credRepos=None, 
    133134                 mapFromTrustedHosts=False, 
     
    140141                                If not set here, it must be input in call 
    141142                                to reqAuthorisation 
     143        clntCertFilePath:       Public key certificate for this client.  
     144                                Setting this enables return message from AA  
     145                                WSDL to be encrypted by the AA. 
    142146        credRepos:              Credential Repository instance 
    143147        mapFromTrustedHosts:   sets behaviour for reqAuthorisation().  If 
     
    159163        self.proxyCertTxt = proxyCertTxt 
    160164         
    161         self.__caCertFilePath = caCertFilePath 
     165        if caCertFilePath: 
     166            self.__setCAcertFilePath(caCertFilePath) 
     167        else: 
     168            self.__caCertFilePath = None 
     169             
     170        if clntCertFilePath: 
     171            self.__setClntCertFilePath(clntCertFilePath) 
     172        else: 
     173            self.__clntCertFilePath = None 
     174                  
    162175        self.__credRepos = credRepos 
    163176         
     
    288301                           doc="List of Attribute Certificates")    
    289302 
    290          
     303 
     304    #_________________________________________________________________________ 
     305    def __setCAcertFilePath(self, caCertFilePath): 
     306         
     307        if not isinstance(caCertFilePath, basestring): 
     308            raise CredWalletError(\ 
     309                "Input CA Certificate file path is not valid") 
     310                 
     311        self.__caCertFilePath = caCertFilePath 
     312        
     313         
     314    caCertFilePath = property(fset=__setCAcertFilePath, 
     315                              doc="CA Certificate  - use to check AC XML Sig") 
     316 
     317 
     318    #_________________________________________________________________________ 
     319    def __setClntCertFilePath(self, clntCertFilePath): 
     320         
     321        if not isinstance(clntCertFilePath, basestring): 
     322            raise CredWalletError(\ 
     323                "Input Client Certificate file path is not valid") 
     324                 
     325        self.__clntCertFilePath = clntCertFilePath 
     326        
     327         
     328    clntCertFilePath = property(fset=__setClntCertFilePath, 
     329                    doc="Client Certificate  - use to encrypt resp from AA") 
    291330 
    292331 
     
    407446         
    408447    def __reqAuthorisation(self, 
     448                           aaPropFilePath=None, 
    409449                           aaWSDL=None, 
    410                            aaPropFilePath=None, 
     450                           aaCertFilePath=None, 
    411451                           extAttCert=None, 
    412452                           bDebug=False): 
     
    426466                                specify a local Attribute Authority 
    427467                                configuration file. 
    428                                  
    429         extAttCert:            an existing Attribute Certificate which can be 
     468  
     469        aaCertFilePath:         Public key certificate for Attribute  
     470                                Authority.  Pass this to enable message level 
     471                                encryption of outgoing message to AA WS. 
     472                                Applies only where aaWSDL is set.  If omitted, 
     473                                outgoing message is not enrypted.  In this 
     474                                case SSL could be used instead to encrypt the  
     475                                message. 
     476        extAttCert:             an existing Attribute Certificate which can be 
    430477                                used to making a mapping should the user not 
    431478                                be registered with the Attribute Authority""" 
     
    447494                                      "path must be a valid string") 
    448495 
     496            if self.__clntCertFilePath: 
     497                clntCertTxt = \ 
     498                    X509Cert(filePath=self.__clntCertFilePath).asString() 
     499            else: 
     500                clntCertTxt = None 
     501                 
     502                 
    449503            try:                 
    450504                # Get Attribute Authority web service interface 
     
    459513                 
    460514                # Format XML request message 
     515                # 
     516                # Message will be encrypted if aaCertFilePath was set 
    461517                authorisationReq = AuthorisationReq(\ 
    462                                             proxyCertTxt=self.__proxyCertTxt, 
    463                                             userAttCertTxt=extAttCertTxt) 
     518                                            proxyCert=self.__proxyCertTxt, 
     519                                            userAttCert=extAttCertTxt, 
     520                                            clntCert=clntCertTxt, 
     521                                            encrPubKeyFilePath=aaCertFilePath) 
    464522                               
    465523                # Call Attribute Authority's Web service 
    466                 resp=aaSrv.reqAuthorisation(authorisationReq=authorisationReq) 
    467  
    468             except socket.error, e: 
    469                 raise CredWalletError("Requesting authorisation: %s" % e[1]) 
     524                resp = aaSrv.reqAuthorisation(\ 
     525                                         authorisationReq=authorisationReq()) 
     526 
     527            except socket.error, (dummy, e): 
     528                raise CredWalletError("Requesting authorisation: %s" % str(e)) 
    470529                 
    471530            except Exception, e: 
     
    474533 
    475534            # Parse the response 
    476             authorisationResp = AuthorisationResp(xmlTxt=str(resp)) 
     535            authorisationResp = AuthorisationResp(\ 
     536                                    xmlTxt=str(resp['authorisationResp'])) 
     537                                     
    477538            # Check the status code returned from the authorisation request 
    478539            if authorisationResp['statCode'] == authorisationResp.accessError: 
     
    480541             
    481542            elif authorisationResp['statCode'] == \ 
    482                                             authorisationResp.AccessDenied: 
     543                                            authorisationResp.accessDenied: 
    483544                raise CredWalletAuthorisationDenied(\ 
    484545                            "Authorisation denied: %s" % str(resp['errMsg'])) 
     
    486547            elif authorisationResp['statCode'] == \ 
    487548                                            authorisationResp.accessGranted: 
    488                 attCertTxt = authorisationResp['attCert'] 
     549                attCert = authorisationResp['credential'] 
    489550 
    490551            else: 
     
    507568                # Request a new attribute certificate from the Attribute 
    508569                # Authority 
    509                 attCertTxt = aa.authorise(proxyCertTxt=self.__proxyCertTxt, 
    510                                           userAttCertTxt=extAttCertTxt) 
     570                attCert = aa.authorise(proxyCert=self.__proxyCertTxt, 
     571                                       userAttCertTxt=extAttCertTxt) 
    511572                 
    512573            except AttAuthorityAccessDenied, e: 
     
    521582                                  "a WSDL file or Attribute Authority " + \ 
    522583                                  "configuration file must be specified") 
    523  
    524          
    525         # Convert text into Attribute Certificate object 
    526         try: 
    527             attCert = AttCertParse(attCertTxt) 
    528              
    529         except Exception, e: 
    530             raise CredWalletError("Parsing Attribute Certificate returned " +\ 
    531                                   "from authorisation request: %s" % e) 
    532584         
    533585 
     
    628680 
    629681 
    630      
    631  
     682    #_________________________________________________________________________ 
    632683    def reqAuthorisation(self, 
    633684                         reqRole=None, 
     685                         aaPropFilePath=None, 
    634686                         aaWSDL=None, 
    635                          aaPropFilePath=None, 
     687                         aaCertFilePath=None, 
     688                         clntCertFilePath=None, 
    636689                         caCertFilePath=None, 
    637690                         mapFromTrustedHosts=None, 
     
    651704                                specify a local Attribute Authority 
    652705                                configuration file. 
     706 
     707        aaCertFilePath:         Public key certificate for Attribute  
     708                                Authority.  Pass this to enable message level 
     709                                encryption of outgoing message to AA WS. 
     710                                Applies only where aaWSDL is set.  If omitted, 
     711                                outgoing message is not enrypted.  In this 
     712                                case SSL could be used instead to encrypt the  
     713                                message. 
     714                                 
     715        clntCertFilePath:       Public key certificate for this client.  
     716                                Setting this enables return message from AA  
     717                                WSDL to be encrypted by the AA. 
     718 
    653719        caCertFilePath:         Certificate Authority's certificate used to 
    654720                                validate the signature of any Attribute 
     
    656722                                Authority 
    657723 
    658         mapFromTrustedHosts:   if authorisation fails via the user's proxy 
     724        mapFromTrustedHosts:    if authorisation fails via the user's proxy 
    659725                                certificate, then it is possible to get a 
    660726                                mapped certificate by using certificates from 
     
    714780 
    715781        if caCertFilePath is not None: 
    716             if not isinstance(caCertFilePath, basestring): 
    717                 raise CredWalletError(\ 
    718                     "Input CA Certificate file path is not valid") 
    719                      
    720             self.__caCertFilePath = caCertFilePath 
    721              
     782            self.caCertFilePath = caCertFilePath 
     783             
     784        if clntCertFilePath is not None: 
     785            self.clntCertFilePath = clntCertFilePath 
     786 
    722787             
    723788        # Check for settings from input, if not set use previous settings 
     
    777842                attCert = self.__reqAuthorisation(aaWSDL=aaWSDL, 
    778843                                                aaPropFilePath=aaPropFilePath, 
     844                                                aaCertFilePath=aaCertFilePath, 
    779845                                                extAttCert=extAttCert)                 
    780846                # Access granted 
  • security/trunk/python/NDG/Session.py

    r533 r539  
    529529                    # Encrypt response if a client public key is available 
    530530                    connectResp = ConnectResp(sessCookie=sessCookie, 
    531                                       encrPubKeyFilePath=clntPubKeyFilePath, 
    532                                       noEncrypt=(not clntPubKeyFilePath)) 
     531                                      encrPubKeyFilePath=clntPubKeyFilePath) 
    533532                except Exception, e: 
    534533                    raise SessionMgrError(\ 
     
    538537                try: 
    539538                    connectResp = ConnectResp(proxyCert=proxyCert, 
    540                                       encrPubKeyFilePath=clntPubKeyFilePath, 
    541                                       noEncrypt=(not clntPubKeyFilePath)) 
     539                                      encrPubKeyFilePath=clntPubKeyFilePath) 
    542540                except Exception, e: 
    543541                    raise SessionMgrError(\ 
  • security/trunk/python/NDG/SessionClient.py

    r538 r539  
    2121 
    2222from X509 import * 
    23 from SessionMgrIO  import * 
     23from SessionMgrIO import * 
    2424 
    2525 
     
    261261                                             
    262262            resp = self.__smSrv.reqAuthorisation(authorisationReq=authReq()) 
    263             authResp = AuthorisationResp(xmlTxt=resp._authorisationResp) 
     263            authResp = AuthorisationResp(xmlTxt=resp['authorisationResp']) 
    264264            return authResp 
    265265             
     
    278278    try: 
    279279         
    280         aaWSDL = '../attAuthority.wsdl' 
     280        aaWSDL = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
    281281         
    282282        # Session Manager WSDL 
    283         smWSDL = '../sessionMgr.wsdl' 
     283        smWSDL = 'http://glue.badc.rl.ac.uk/sessionMgr.wsdl' 
    284284         
    285285        # Public key of session manager used to encrypt requests 
  • security/trunk/python/NDG/SessionMgrIO.py

    r533 r539  
    9797                         
    9898 
    99     def __init__(self, noEncrypt=True, **xmlMsgKeys): 
     99    def __init__(self, **xmlMsgKeys): 
    100100        """XML for receiving credentials from Session Manager connect call 
    101101         
    102102        xmlMsgKeys:    keywords for XMLMsg super-class.  If XML tags are  
    103103                       input as keywords then 'proxyCert' or 'sessCookie'  
    104                        must be set. 
    105                          
    106                        Note: noEncrypt=True must be set otherwise an 
    107                        exception will be raised. 
     104                       must be set.                         
    108105        """         
    109106         
    110107        # Allow user credentials to be access like dictionary keys 
    111         super(self.__class__, self).__init__(noEncrypt=True, **xmlMsgKeys) 
     108        super(self.__class__, self).__init__(**xmlMsgKeys) 
    112109         
    113110                                
     
    183180                         
    184181 
    185     def __init__(self, noEncrypt=True, **xmlMsgKeys): 
     182    def __init__(self, **xmlMsgKeys): 
    186183        """XML for returning error status from Session Manager addUser() 
    187184         
     
    189186                       input as keywords then 'proxyCert' or 'sessCookie'  
    190187                       must be set. 
    191                          
    192                        Note: noEncrypt=True must be set otherwise an 
    193                        exception will be raised. 
    194188        """ 
    195189                 
    196190        # Allow user credentials to be access like dictionary keys 
    197         super(self.__class__, self).__init__(noEncrypt=True, **xmlMsgKeys) 
     191        super(self.__class__, self).__init__(**xmlMsgKeys) 
    198192         
    199193                                
     
    278272 
    279273 
    280     def __init__(self, noEncrypt=True, **xmlMsgKeys): 
     274    def __init__(self, **xmlMsgKeys): 
    281275        """XML for receiving output from Session Manager authorisation call 
    282276         
     
    284278                       input as keywords then 'errMsg' or 'statCode'  
    285279                       must be set. 
    286                          
    287                        Note: noEncrypt=True must be set otherwise an 
    288                        exception will be raised. 
    289280        """         
    290281         
    291282        # Allow user credentials to be access like dictionary keys 
    292         super(self.__class__, self).__init__(noEncrypt=True, **xmlMsgKeys) 
     283        super(self.__class__, self).__init__(**xmlMsgKeys) 
    293284         
    294285                                
     
    314305      
    315306      
    316         # Join into single string and filter out XML headers as ElementTree  
    317         # doesn't like these nested into a doc 
    318         def setAttCert(attCert): 
    319             if isinstance(attCert, basestring): 
    320                 return AttCertParse(attCert) 
    321             elif isinstance(attCert, AttCert): 
    322                 return attCert 
    323             else: 
    324                 raise TypeError(\ 
    325                     "extAttCertList must contain string or AttCert types") 
    326                      
    327         attCertList = map(setAttCert, extAttCertList) 
    328          
     307            # Join into single string and filter out XML headers as   
     308            # ElementTree doesn't like these nested into a doc 
     309            def setAttCert(attCert): 
     310                if isinstance(attCert, basestring): 
     311                    return AttCertParse(attCert) 
     312                 
     313                elif isinstance(attCert, AttCert): 
     314                    return attCert 
     315                else: 
     316                    raise TypeError(\ 
     317                        "extAttCertList must contain string or AttCert types") 
     318                         
     319            attCertList = map(setAttCert, extAttCertList) 
     320        else: 
     321            attCertList = None 
    329322                 
    330323        # Call super class update with revised attribute certificate list 
     
    377370         
    378371        rootElem = super(self.__class__, self).parseXML(rtnRootElem=True) 
    379         if 'extAttCertList' not in self: 
    380             # No need to proceed any further if no external attribute cert  
    381             # list element is present 
    382             return 
    383  
     372         
    384373        extAttCertListElem = rootElem.find("extAttCertList") 
    385         if not extAttCertListElem: 
    386             raise AuthorisationRespError("Expecting <extAttCertList> tag") 
    387  
    388         # Add attribute certificates as AttCert instances 
    389         try: 
    390             self['extAttCertList'] = \ 
    391                 [AttCertParse(ElementTree.tostring(elem)) \ 
    392                 for elem in extAttCertListElem] 
    393         except Exception, e: 
    394             raise AuthorisationRespError(\ 
    395                 "Error parsing Ext. Attribute Certificate List: %s" % e)                                 
     374        if extAttCertListElem: 
     375 
     376            # Add attribute certificates as AttCert instances 
     377            try: 
     378                self['extAttCertList'] = \ 
     379                    [AttCertParse(ElementTree.tostring(elem)) \ 
     380                    for elem in extAttCertListElem] 
     381                     
     382            except Exception, e: 
     383                raise AuthorisationRespError(\ 
     384                    "Error parsing Ext. Attribute Certificate List: "+str(e))                                 
    396385  
    397386                                         
     
    409398 
    410399    # Server side - make a connect response message 
    411 #    cr1 = ConnectResp(sessCookie="A proxy certificate", noEncrypt=True) 
     400#    cr1 = ConnectResp(sessCookie="A proxy certificate") 
    412401# 
    413402#    cr2 = ConnectResp(sessCookie="A session cookie",  
  • security/trunk/python/NDG/XMLSecDoc.py

    r530 r539  
    1717import types 
    1818import os 
     19 
     20# For asString() - enables XML header to be stripped if required 
     21import re 
    1922 
    2023# Use to create buffer for string output for asString() method 
     
    428431 
    429432    #_________________________________________________________________________ 
    430     def asString(self, filePath=None): 
     433    def asString(self, filePath=None, stripXMLhdr=False): 
    431434        """Return certificate file content as a string""" 
    432435         
     
    444447            self.__libxml2Doc.saveFormatFileTo(buf, 'UTF-8', 0) 
    445448 
     449 
    446450            # Return string content 
    447             return f.getvalue() 
     451            if stripXMLhdr: 
     452                return re.sub("<\?xml.*>\s", "", f.getvalue()) 
     453            else: 
     454                return f.getvalue() 
    448455 
    449456        except Exception, e: 
  • security/trunk/python/NDG/attAuthority_services_server.py

    r535 r539  
    8484         
    8585        try: 
    86             attCertTxt = self.__srv.authorise(reqXMLtxt=reqTxt) 
    87             resp._authorisationResp = \ 
    88                 str(AuthorisationResp(attCertTxt=attCertTxt)) 
    89               
     86            attCert = self.__srv.authorise(reqXMLtxt=reqTxt) 
     87             
     88            authorisationResp = AuthorisationResp(\ 
     89                                    credential=str(attCert), 
     90                                    statCode=AuthorisationResp.accessGranted) 
     91             
     92        except AttAuthorityAccessDenied, e: 
     93            authorisationResp = AuthorisationResp(errMsg=str(e), 
     94                                    statCode=AuthorisationResp.accessDenied) 
     95             
    9096        except Exception, e: 
    91             resp._authorisationResp = str(AuthorisationResp(errMsg=str(e))) 
     97            authorisationResp = AuthorisationResp(errMsg=str(e), 
     98                                    statCode=AuthorisationResp.accessError) 
    9299         
     100         
     101        resp._authorisationResp = str(authorisationResp) 
    93102        return resp 
Note: See TracChangeset for help on using the changeset viewer.