Changeset 2028 for TI12-security


Ignore:
Timestamp:
23/01/07 10:27:18 (13 years ago)
Author:
pjkersha
Message:

python/ndg.security.server/ndg/security/server/AttAuthority/server-config.tac:
Working soap_getAttCert and soap_getX509Cert. Added ndg.common.X509 imports.

python/ndg.security.server/ndg/security/server/AttAuthority/init.py:

  • allow ndg.common.X509 type input for getAttCert
  • fixes to getAttCert for new XMLSecDoc code usedto sign Attribute Certificate

python/conf/attAuthorityProperties.xml: "attCertLifeTime" -> "attCertLifetime"

python/ndg.security.test/ndg/security/test/AttAuthority/AttAuthorityClientTest.py:
fix to testGetAttCert to correctly print output

python/ndg.security.test/ndg/security/test/AttAuthority/attAuthorityProperties.xml:
properties file for test harness - fix "attCertLifeTime" -> "attCertLifetime"

python/ndg.security.test/ndg/security/test/MyProxy/myProxyClientTest.cfg:
swap username for tests.

python/ndg.security.common/ndg/security/common/XMLSec.py:

  • Added code to correctly parse certificate from ds:X509Certificate element of

signature.

  • replaced calls to getAttributeNodeNS with getAttributeNode as former was

returning None for some attributes?! getAttributeNode seems to be the more
correct call.

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

  • Fix so that new X509Cert object can be created from an M2Crypto one with the

m2CryptoX509 keyword to init. Also see method setFromM2Crypto.

  • Renamed to asString to toString in line with convention for other classes.
  • Added property "verifyingCert"

python/ndg.security.common/ndg/security/common/SQLObject.py:

  • fixed reference to attCert string conversion - do as implicit call to

AttCert?.str

Location:
TI12-security/trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/conf/attAuthorityProperties.xml

    r2017 r2028  
    66    <certFile></certFile> 
    77    <caCertFile></caCertFile> 
    8     <attCertLifeTime></attCertLifeTime> 
     8    <attCertLifetime></attCertLifetime> 
    99        <attCertNotBeforeOff>0</attCertNotBeforeOff> 
    1010    <attCertFilePfx>ac-</attCertFilePfx> 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SQLObject.py

    r1642 r2028  
    304304        try: 
    305305            for attCert in attCertList: 
    306                 self.UserCredential(dn=dn, attCert=attCert.asString()) 
     306                self.UserCredential(dn=dn, attCert=str(attCert)) 
    307307 
    308308        except Exception, e: 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/X509.py

    r1990 r2028  
    3131    "NDG X509 Certificate Handling" 
    3232 
    33     def __init__(self, filePath=None): 
     33    def __init__(self, filePath=None, m2CryptoX509=None): 
    3434 
    3535        # Set certificate file path 
     
    3939                        "Certificate File Path input must be a valid string" 
    4040             
    41             self.__filePath = filePath 
    42         self.__m2CryptoX509 = None 
     41            self.__filePath = filePath             
    4342        self.__dn = None 
    4443        self.__dtNotBefore = None 
    4544        self.__dtNotAfter = None 
    4645         
     46        if m2CryptoX509: 
     47            self.__setM2CryptoX509(m2CryptoX509) 
     48                 
    4749 
    4850    def __str__(self): 
     
    5658 
    5759    def __repr__(self): 
    58         """Override to display current certificate file setting.""" 
    59          
     60        """Override to display current certificate file setting."""  
    6061        return str(self) 
    6162         
     
    6465        """Read a certificate from file""" 
    6566         
    66         # Check for optional input certificate file path 
    67         if filePath is not None: 
    68  
     67        # Check for optional input certificate file path 
     68        if filePath is not None: 
    6969            if not isinstance(filePath, basestring): 
    70                 raise X509CertError(\ 
    71                     "Certificate File Path input must be a valid string") 
     70                raise X509CertError, \ 
     71                    "Certificate File Path input must be a valid string" 
    7272             
    7373            self.__filePath = filePath 
     
    7676            self.__m2CryptoX509 = M2Crypto.X509.load_cert(self.__filePath) 
    7777        except Exception, e: 
    78             raise X509CertError("Error loading certificate \"%s\": %s" % \ 
    79                                 (self.__filePath, str(e))) 
     78            raise X509CertError, "Error loading certificate \"%s\": %s" % \ 
     79                                (self.__filePath, str(e)) 
    8080 
    8181        # Update DN and validity times from M2Crypto X509 object just 
    8282        # created 
    83         self.__setFromM2Crypto() 
     83        self.__setM2CryptoX509() 
    8484 
    8585 
     
    9999             
    100100        except Exception, e: 
    101             raise X509CertError("Error loading certificate: %s" % str(e)) 
     101            raise X509CertError, "Error loading certificate: %s" % str(e) 
    102102 
    103103        # Update DN and validity times from M2Crypto X509 object just 
    104104        # created 
    105         self.__setFromM2Crypto() 
    106  
    107  
    108          
    109          
    110     def __setFromM2Crypto(self): 
     105        self.__setM2CryptoX509() 
     106 
     107 
     108         
     109         
     110    def __setM2CryptoX509(self, m2CryptoX509=None): 
    111111        """Private method allows class members to be updated from the 
    112112        current M2Crypto object.  __m2CryptoX509 must have been set.""" 
    113113         
     114        if m2CryptoX509 is not None: 
     115            if not isinstance(m2CryptoX509, M2Crypto.X509.X509): 
     116                raise TypeError, \ 
     117                    "Incorrect type for input M2Crypto.X509.X509 object" 
     118                     
     119            self.__m2CryptoX509 = m2CryptoX509 
     120             
     121             
    114122        # Get distinguished name 
    115123        m2CryptoX509Name = self.__m2CryptoX509.get_subject() 
     
    130138                                         
    131139        except Exception, e: 
    132             raise X509CertError("Not Before time: " + str(e)) 
     140            raise X509CertError, "Not Before time: " + str(e) 
    133141 
    134142         
     
    138146                                     
    139147        except Exception, e: 
    140             raise X509CertError("Not After time: " + str(e)) 
    141  
    142  
    143  
    144          
    145     def asString(self, filePath=None): 
     148            raise X509CertError, "Not After time: " + str(e) 
     149 
     150    m2CryptoX509 = property(fset=__setM2CryptoX509, 
     151                        doc="Set X509Cert from an M2Crypto.X509.X509 type") 
     152 
     153         
     154    def toString(self, filePath=None): 
    146155        """Return certificate file content as a string""" 
    147156         
     
    151160            self.read(filePath) 
    152161             
    153         return self.__m2CryptoX509.Print() 
     162        return self.__m2CryptoX509.as_pem() 
    154163 
    155164     
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/XMLSec.py

    r1973 r2028  
    7272#_____________________________________________________________________________ 
    7373class XMLSecDoc(object): 
    74     """Implements XML Signature and XML Encryption for a Document.""" 
     74    """Implements XML Signature and XML Encryption for a Document. 
     75     
     76    @type __beginCert: string 
     77    @param __beginCert: delimiter for beginning of base64 encoded portion of 
     78    a PEM encoded X.509 certificate 
     79    @type __endCert: string 
     80    @cvar: __endCert: equivalent end delimiter 
     81     
     82    @type __x509CertPat: regular expression pattern object 
     83    @cvar __x509CertPat: regular expression for extracting the base64 encoded  
     84    portion of a PEM encoded X.509 certificate""" 
     85     
     86    __beginCert = '-----BEGIN CERTIFICATE-----\n' 
     87    __endCert = '\n-----END CERTIFICATE-----' 
     88    __x509CertPat = re.compile(__beginCert + \ 
     89                               '?(.*?)\n?-----END CERTIFICATE-----', 
     90                               re.S) 
    7591 
    7692    def __init__(self, 
    7793                 filePath=None, 
    7894                 signingKeyFilePath=None, 
     95                 signingKeyPwd=None, 
    7996                 certFilePathList=None, 
    8097                 encrCertFilePath=None, 
     
    107124        if signingKeyFilePath is not None: 
    108125            self.__setSigningKeyFilePath(signingKeyFilePath) 
     126 
     127        # Password proetcting Private key used to sign the document - password 
     128        # may be None 
     129        self.__setSigningKeyPwd(signingKeyPwd) 
    109130 
    110131        # Public key file to be used to encrypt document 
     
    541562        @param certFilePathList: Certificate used to sign the document.""" 
    542563 
    543         # Check Certificate files for read access 
    544         if not self.__certFilePathList:                 
    545             raise VerifyError, "No certificate files set for check" 
    546564         
    547565        if xmlTxt: 
     
    611629        # Get transforms that were applied 
    612630        try: 
    613             transformsNode = getElements(refNode, "Transforms")[0] 
    614             transforms = getElements(transformsNode, "Transform") 
     631            tfmsNode = getElements(refNode, "Transforms")[0] 
     632            tfmNodes = getElements(tfmsNode, "Transform") 
    615633 
    616634        except Exception, e: 
     
    624642        envelopedAlgorithmSet = False 
    625643         
    626         for transform in transforms: 
    627             refAlgorithm=transform.getAttributeNodeNS(None, "Algorithm").value 
    628             if refAlgorithm == DSIG.C14N_EXCL: 
    629                 try: 
    630                     inclusiveNSnode = getElements(transform,  
    631                                               "InclusiveNamespaces")[0] 
    632                      
    633                     pfxListAttNode = inclusiveNSnode.getAttributeNodeNS(None,  
     644        try: 
     645            for tfmNode in tfmNodes: 
     646                refAlgorithm = tfmNode.getAttributeNode('Algorithm').value 
     647                #refAlgorithm=tfmNode.getAttributeNodeNS(None, "Algorithm").value 
     648                 
     649                if refAlgorithm == DSIG.C14N_EXCL: 
     650                        inclusiveNSnode = getElements(tfmNode,  
     651                                                  "InclusiveNamespaces")[0] 
     652                         
     653#                        pfxListAttNode = inclusiveNSnode.getAttributeNodeNS(None,  
     654#                                                                   'PrefixList') 
     655                        pfxListAttNode = inclusiveNSnode.getAttributeNode(\ 
    634656                                                               'PrefixList') 
    635                     refC14nKw['unsuppressedPrefixes'] = \ 
     657                        refC14nKw['unsuppressedPrefixes'] = \ 
    636658                                                pfxListAttNode.value.split() 
    637                     break 
    638                 except Exception, e: 
    639                     raise VerifyError, 'Failed to parse exclusive ' + \ 
    640                                     'canonicalisation transform: %s' % str(e) 
    641             elif refAlgorithm == DSIG.ENVELOPED: 
    642                 envelopedAlgorithmSet = True 
    643          
     659                        break 
     660                elif refAlgorithm == DSIG.ENVELOPED: 
     661                    envelopedAlgorithmSet = True 
     662        except Exception, e: 
     663            raise VerifyError, 'Failed to parse tranform node: %s' % str(e) 
     664        
    644665         
    645666        if not envelopedAlgorithmSet: 
     
    668689        # element.  Nb. This is NOT necessarily the same as that used to 
    669690        # canonicalize the reference elements checked above! 
    670         signedInfoC14nAlg = c14nMethodNode.getAttributeNodeNS(None,  
    671                                                          "Algorithm").value 
    672         signedInfoC14nKw = {} 
    673         if signedInfoC14nAlg == DSIG.C14N_EXCL: 
    674             try: 
     691        try: 
     692            signedInfoC14nAlg = c14nMethodNode.getAttributeNode(\ 
     693                                                            "Algorithm").value 
     694            signedInfoC14nKw = {} 
     695            if signedInfoC14nAlg == DSIG.C14N_EXCL: 
    675696                inclusiveNS = getElements(c14nMethodNode, 
    676697                                          "InclusiveNamespaces") 
    677698                 
    678                 pfxListAttNode = inclusiveNS[0].getAttributeNodeNS(None,  
    679                                                                'PrefixList') 
     699                pfxListAttNode = inclusiveNS[0].getAttributeNode('PrefixList') 
    680700                signedInfoC14nKw['unsuppressedPrefixes'] = \ 
    681701                                                pfxListAttNode.value.split() 
    682             except Exception, e: 
    683                 raise VerifyError, 'failed to handle exclusive ' + \ 
     702        except Exception, e: 
     703            raise VerifyError, 'failed to handle exclusive ' + \ 
    684704                                'canonicalisation for SignedInfo: %s' % str(e) 
    685705         
     
    702722        calcSignedInfoDigestValue = sha(signedInfoC14n).digest() 
    703723 
    704  
    705         # Try extracting X.509 Cert from ds:X509Certificate node in KeyInfo 
    706         try: 
     724        try: 
     725            # Try extracting X.509 Cert from ds:X509Certificate node in  
     726            # KeyInfo 
    707727            x509CertNode = xpath.Evaluate('//ds:X509Certificate', 
    708728                                          contextNode=self.__docNode, 
    709729                                          context=ctx)[0] 
    710             x509str = x509CertNode.childNodes[0]._get_nodeValue() 
    711      
    712             raise Exception, "Try reading from file" 
    713             x509Cert = X509.load_cert_string(x509str) 
    714         except: 
    715             # No ds:X509Certificate element present - read from file instead   
    716             x509Cert = X509.load_cert(self.__certFilePathList[0]) 
    717  
    718    
    719         # Once the required information has been extracted from the Signature 
    720         # node it can be removed 
    721         parentNode.removeChild(signatureNode) 
     730            b64EncX509Cert = self.__class__.__beginCert + \ 
     731                         str(x509CertNode.childNodes[0]._get_nodeValue()) + \ 
     732                         self.__class__.__endCert 
     733 
     734            x509Cert = X509.load_cert_string(b64EncX509Cert) 
     735             
     736        except Exception, e: 
     737            raise VerifyError, \ 
     738                'Unable to read certificate from "ds:X509Certificate" element' 
     739 
     740 
     741        # Temporarily remove the Signature node in order to correctly 
     742        # canonicalize the reference 
     743        signatureNode = parentNode.removeChild(signatureNode) 
    722744         
    723745         
     
    732754        calcDigestValue = base64.encodestring(sha(refC14n).digest()).strip() 
    733755         
     756        # Restore signature node 
     757        parentNode.appendChild(signatureNode) 
     758         
     759         
    734760        # Reference validates if the newly calculated digest value and the  
    735761        # digest value extracted from the Reference section of the SignedInfo  
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/wsSecurity.py

    r2017 r2028  
    9696                               re.S) 
    9797     
     98    def __getVerifyingCert(self): 
     99        '''Return X.509 cert object corresponding to cert used to verify the  
     100        signature in the last call to verify 
     101         
     102         * Cert will correspond to one used in the LATEST call to verify, on 
     103         the next call it will be replaced 
     104         * if verify hasn't been called, the cert will be None 
     105         
     106        @rtype: M2Crypto.X509.X509 
     107        @return: certificate object 
     108        ''' 
     109        return self.__verifyingCert 
     110     
     111    verifyingCert = property(fget=__getVerifyingCert, 
     112                             doc="X.509 obj for cert that verified signature") 
     113     
     114     
    98115    def __init__(self, 
    99116                 certFilePath=None,  
     
    104121        self.__priKeyFilePath = priKeyFilePath 
    105122        self.__priKeyPwd = priKeyPwd 
    106  
     123         
     124        # X.509 cert object corresponding to cert used to verify the signature 
     125        # in the last call to verify - set to None until verify is called 
     126        self.__verifyingCert = None 
    107127 
    108128    def sign(self, soapWriter): 
     
    450470 
    451471        # Look for X.509 Cert in wsse:BinarySecurityToken node 
    452         import pdb;pdb.set_trace() 
    453472        try: 
    454473            binSecTokNode = xpath.Evaluate('//wsse:BinarySecurityToken', 
     
    456475                                           context=ctxt)[0] 
    457476                                            
    458             b64EncX509Cert = str(self.__class__.__beginCert + \ 
    459                              binSecTokNode.childNodes[0]._get_nodeValue() + \ 
    460                              self.__class__.__endCert) 
    461              
    462             x509Cert = X509.load_cert_string(b64EncX509Cert) 
     477            b64EncX509Cert = self.__class__.__beginCert + \ 
     478                         str(binSecTokNode.childNodes[0]._get_nodeValue()) + \ 
     479                         self.__class__.__endCert 
     480             
     481            self.__verifyingCert = X509.load_cert_string(b64EncX509Cert) 
    463482        except: 
    464483            # If not, check cert file     
    465             x509Cert = X509.load_cert(self.__certFilePath) 
     484            self.__verifyingCert = X509.load_cert(self.__certFilePath) 
    466485         
    467486        # Extract RSA public key from the cert 
    468         rsaPubKey = x509Cert.get_pubkey().get_rsa() 
     487        rsaPubKey = self.__verifyingCert.get_pubkey().get_rsa() 
    469488         
    470489        # Apply the signature verification 
     
    478497            raise VerifyError, "Invalid signature" 
    479498         
    480 #        import pdb;pdb.set_trace() 
    481         print "Signature OK" 
     499        #print "Signature OK" 
    482500 
    483501 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/AttAuthority/__init__.py

    r2017 r2028  
    8383                    'certFile', 
    8484                    'caCertFile', 
    85                     'attCertLifeTime', 
     85                    'attCertLifetime', 
    8686                    'attCertNotBeforeOff', 
    8787                    'attCertFilePfx', 
     
    286286                   [userAttCert=cert|userAttCertFilePath=certFile]) 
    287287                    
    288         @type proxyCert: string 
    289         @keyword proxyCert: base64 encoded string containing user proxy cert. 
     288        @type proxyCert: string / ndg.security.common.X509.X509Cert type 
     289        @keyword proxyCert: base64 encoded string containing user proxy cert./ 
     290        X.509 cert object 
    290291         
    291292        @keyword proxyCertFilePath: string 
     
    306307 
    307308        # Read proxy certificate 
    308         try: 
    309             usrProxyCert = X509Cert() 
    310              
     309        try:             
    311310            if proxyCertFilePath is not None: 
    312311                                     
    313312                # Proxy Certificate input as a file  
     313                usrProxyCert = X509Cert() 
    314314                usrProxyCert.read(proxyCertFilePath) 
    315315                 
    316             elif proxyCert is not None: 
     316            elif isinstance(proxyCert, basestring): 
    317317 
    318318                # Proxy Certificate input as string text 
     319                usrProxyCert = X509Cert() 
    319320                usrProxyCert.parse(proxyCert) 
     321                 
     322            elif isinstance(proxyCert, X509Cert): 
     323                 
     324                # Proxy is an NDG X509Cert type 
     325                usrProxyCert = proxyCert 
     326                 
    320327            else: 
    321328                raise AttAuthorityError, \ 
    322                     "no input proxy certificate file path or file text set" 
     329                "No input proxy certificate file path or cert text/object set" 
    323330             
    324331        except Exception, e: 
     
    344351        # Nb. new attribute certificate file path is created from the 
    345352        # Credentials Repository 
    346         certFilePathList = [self.__prop['certFile'],self.__prop['caCertFile']] 
    347         attCert = AttCert(self.__newAttCertFilePath(), 
    348                           signingKeyFilePath=self.__prop['keyFile'], 
    349                           certFilePathList=certFilePathList) 
    350  
    351  
     353        attCert = AttCert(filePath=self.__newAttCertFilePath()) 
     354 
     355        attCert.certFilePathList = [self.__prop['certFile'], 
     356                                    self.__prop['caCertFile']] 
     357         
     358        attCert.signingKeyFilePath = self.__prop['keyFile'] 
     359        attCert.signingKeyPwd = self.__prop['keyPwd'] 
     360         
     361         
    352362        # Set holder's (user's) Distinguished Name 
    353363        try: 
     
    375385        try: 
    376386            attCert.setValidityTime(\ 
    377                         lifeTime=self.__prop['attCertLifeTime'], 
     387                        lifetime=self.__prop['attCertLifetime'], 
    378388                        notBeforeOffset=self.__prop['attCertNotBeforeOff']) 
    379389 
     
    496506            # Digitally sign certificate using Attribute Authority's 
    497507            # certificate and private key 
    498             attCert.sign(signingKeyPwd=self.__prop['keyPwd']) 
     508            attCert.applyEnvelopedSignature() 
    499509             
    500510            # Check the certificate is valid 
     
    569579  
    570580        # Ensure Certificate time parameters are converted to numeric type 
    571         self.__prop['attCertLifeTime'] = float(self.__prop['attCertLifeTime']) 
     581        self.__prop['attCertLifetime'] = float(self.__prop['attCertLifetime']) 
    572582        self.__prop['attCertNotBeforeOff'] = \ 
    573583                                    float(self.__prop['attCertNotBeforeOff']) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/AttAuthority/server-config.tac

    r2017 r2028  
    2222 
    2323from AttAuthority_services_server import AttAuthorityService 
     24 
    2425from ndg.security.server.AttAuthority import AttAuthority 
    2526from ndg.security.common.wsSecurity import WSSecurityHandlerChainFactory, \ 
    2627        WSSecurityHandler, SignatureHandler 
     28 
     29from ndg.security.common.X509 import X509Cert, X509CertRead 
    2730 
    2831 
     
    4043 
    4144    def soap_getAttCert(self, ps, **kw): 
    42         #import pdb;pdb.set_trace() 
     45        import pdb;pdb.set_trace() 
    4346        request, response = AttAuthorityService.soap_getAttCert(self, ps) 
    44           
    45         attCert = self.aa.getAttCert(\ 
    46                                                   proxyCert=request.get_element_userCert(), 
     47         
     48        # Get certificate corresponding to private key that signed the 
     49        # message - i.e. the user's proxy 
     50        proxyCert = X509Cert(\ 
     51                m2CryptoX509=WSSecurityHandler.signatureHandler.verifyingCert) 
     52                 
     53        attCert = self.aa.getAttCert(proxyCert=proxyCert, 
    4754                                                  userAttCert=request.get_element_userAttCert()) 
    4855        response.set_element_attCert(attCert) 
     
    5259        import pdb;pdb.set_trace() 
    5360        request, response = AttAuthorityService.soap_getHostInfo(self, ps) 
    54         response.set_element_hostInfo('HOST INFO') 
     61        response.set_element_host(aaSrv.aa.hostInfo) 
    5562        return request, response 
    5663 
    5764    def soap_getTrustedHostInfo(self, ps, **kw): 
    58         #import pdb;pdb.set_trace() 
     65        import pdb;pdb.set_trace() 
    5966        request, response = \ 
    6067                AttAuthorityService.soap_getTrustedHostInfo(self, ps) 
    61         response.set_element_trustedHosts('TRUSTED HOST INFO') 
     68         
     69         
     70        trustedHostInfo = aaSrv.aa.getTrustedHostInfo(\ 
     71                                                                                role=request.get_element_role()) 
     72        response.set_element_trustedHosts(trustedHostInfo) 
    6273        return request, response 
    6374 
    64     def soap_getPubKey(self, ps, **kw): 
     75    def soap_getX509Cert(self, ps, **kw): 
    6576        #import pdb;pdb.set_trace() 
    66         request, response = AttAuthorityService.soap_getPubKey(self, ps) 
    67         response.set_element_x509Cert('X.509 Cert.') 
     77        request, response = AttAuthorityService.soap_getX509Cert(self, ps) 
     78         
     79        x509Cert = X509CertRead(aaSrv.aa['certFile']) 
     80        response.set_element_x509Cert(x509Cert.toString()) 
    6881        return request, response 
    6982 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/AttAuthority/AttAuthorityClientTest.py

    r2017 r2028  
    8383            raise "Error reading certificate file \"%s\": %s" % \ 
    8484                                    (ioErr.filename, ioErr.strerror) 
    85         import pdb;pdb.set_trace() 
     85 
    8686        # Make attribute certificate request 
    8787        attCert = self.clnt.getAttCert(userCert=userCertTxt) 
    88         return attCert 
     88        print "Attribute Certificate: \n\n:" + str(attCert) 
    8989 
    9090 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/AttAuthority/attAuthorityProperties.xml

    r2017 r2028  
    33    <name>Test NDG Data Provider</name> 
    44    <keyFile>$NDGSEC_AA_UNITTEST_DIR/aa-key.pem</keyFile> 
    5     <keyPwd></keyPwd> 
     5    <keyPwd>Junk</keyPwd> 
    66    <certFile>$NDGSEC_AA_UNITTEST_DIR/aa-cert.pem</certFile> 
    77    <caCertFile>$NDGSEC_AA_UNITTEST_DIR/cacert.pem</caCertFile> 
    8     <attCertLifeTime>28800</attCertLifeTime> 
     8    <attCertLifetime>28800</attCertLifetime> 
    99        <attCertNotBeforeOff>0</attCertNotBeforeOff> 
    1010    <attCertFilePfx>ac-</attCertFilePfx> 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/MyProxy/myProxyClientTest.cfg

    r2017 r2028  
    1111 
    1212[test1Store] 
    13 username: gabriel 
     13username: sstljakTestUser 
    1414passphrase: 
    1515certFile: ./userCert.pem 
     
    2020 
    2121[test2GetDelegation] 
    22 username: gabriel 
     22username: sstljakTestUser 
    2323passphrase: 
    2424 
    2525[test3Info] 
    26 username: gabriel 
     26username: sstljakTestUser 
    2727ownerCertFile: ./proxy-cert.pem 
    2828ownerKeyFile: ./proxy-key.pem 
     
    3030 
    3131[test4ChangePassphrase] 
    32 username: gabriel 
     32username: sstljakTestUser 
    3333ownerCertFile: ./proxy-cert.pem 
    3434ownerKeyFile: ./proxy-key.pem 
     
    3838 
    3939[test5Destroy] 
    40 username: gabriel 
     40username: sstljakTestUser 
    4141ownerCertFile: ./proxy-cert.pem 
    4242ownerKeyFile: ./proxy-key.pem 
Note: See TracChangeset for help on using the changeset viewer.