Save This Page
Home » rampart-dist-1.4-src » org.apache » rahas » impl » [javadoc | source]
    1   /*
    2    * Copyright 2004,2005 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
   10    * Unless required by applicable law or agreed to in writing, software
   11    * distributed under the License is distributed on an "AS IS" BASIS,
   12    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   13    * See the License for the specific language governing permissions and
   14    * limitations under the License.
   15    */
   16   
   17   package org.apache.rahas.impl;
   18   
   19   import java.security.Principal;
   20   import java.security.SecureRandom;
   21   import java.security.cert.X509Certificate;
   22   import java.text.DateFormat;
   23   import java.util.Arrays;
   24   import java.util.Date;
   25   
   26   import org.apache.axiom.om.OMElement;
   27   import org.apache.axiom.om.OMNode;
   28   import org.apache.axiom.om.impl.dom.jaxp.DocumentBuilderFactoryImpl;
   29   import org.apache.axiom.soap.SOAPEnvelope;
   30   import org.apache.axis2.context.MessageContext;
   31   import org.apache.axis2.description.Parameter;
   32   import org.apache.rahas.RahasConstants;
   33   import org.apache.rahas.RahasData;
   34   import org.apache.rahas.Token;
   35   import org.apache.rahas.TokenIssuer;
   36   import org.apache.rahas.TrustException;
   37   import org.apache.rahas.TrustUtil;
   38   import org.apache.rahas.impl.util.SAMLAttributeCallback;
   39   import org.apache.rahas.impl.util.SAMLCallbackHandler;
   40   import org.apache.rahas.impl.util.SAMLNameIdentifierCallback;
   41   import org.apache.ws.security.WSConstants;
   42   import org.apache.ws.security.WSSecurityException;
   43   import org.apache.ws.security.WSUsernameTokenPrincipal;
   44   import org.apache.ws.security.components.crypto.Crypto;
   45   import org.apache.ws.security.components.crypto.CryptoFactory;
   46   import org.apache.ws.security.message.WSSecEncryptedKey;
   47   import org.apache.ws.security.util.Base64;
   48   import org.apache.ws.security.util.XmlSchemaDateFormat;
   49   import org.apache.xml.security.signature.XMLSignature;
   50   import org.apache.xml.security.utils.EncryptionConstants;
   51   import org.opensaml.SAMLAssertion;
   52   import org.opensaml.SAMLAttribute;
   53   import org.opensaml.SAMLAttributeStatement;
   54   import org.opensaml.SAMLAuthenticationStatement;
   55   import org.opensaml.SAMLException;
   56   import org.opensaml.SAMLNameIdentifier;
   57   import org.opensaml.SAMLStatement;
   58   import org.opensaml.SAMLSubject;
   59   import org.w3c.dom.Document;
   60   import org.w3c.dom.Element;
   61   import org.w3c.dom.Node;
   62   import org.w3c.dom.Text;
   63   
   64   /**
   65    * Issuer to issue SAMl tokens
   66    */
   67   public class SAMLTokenIssuer implements TokenIssuer {
   68   
   69       private String configParamName;
   70   
   71       private OMElement configElement;
   72   
   73       private String configFile;
   74   
   75       public SOAPEnvelope issue(RahasData data) throws TrustException {
   76   
   77           try {
   78               MessageContext inMsgCtx = data.getInMessageContext();
   79   
   80               SAMLTokenIssuerConfig config = null;
   81               if (this.configElement != null) {
   82                   config = new SAMLTokenIssuerConfig(configElement
   83                                   .getFirstChildWithName(SAMLTokenIssuerConfig.SAML_ISSUER_CONFIG));
   84               }
   85   
   86               // Look for the file
   87               if (config == null && this.configFile != null) {
   88                   config = new SAMLTokenIssuerConfig(this.configFile);
   89               }
   90   
   91               // Look for the param
   92               if (config == null && this.configParamName != null) {
   93                   Parameter param = inMsgCtx.getParameter(this.configParamName);
   94                   if (param != null && param.getParameterElement() != null) {
   95                       config = new SAMLTokenIssuerConfig(param
   96                               .getParameterElement().getFirstChildWithName(
   97                                       SAMLTokenIssuerConfig.SAML_ISSUER_CONFIG));
   98                   } else {
   99                       throw new TrustException("expectedParameterMissing",
  100                               new String[] { this.configParamName });
  101                   }
  102               }
  103   
  104               if (config == null) {
  105                   throw new TrustException("configurationIsNull");
  106               }
  107   
  108               // Set the DOM impl to DOOM
  109               DocumentBuilderFactoryImpl.setDOOMRequired(true);
  110   
  111               SOAPEnvelope env = TrustUtil.createSOAPEnvelope(inMsgCtx
  112                       .getEnvelope().getNamespace().getNamespaceURI());
  113   
  114               Crypto crypto;
  115               if (config.cryptoElement != null) { // crypto props
  116                                                               // defined as
  117                                                               // elements
  118                   crypto = CryptoFactory.getInstance(TrustUtil
  119                           .toProperties(config.cryptoElement), inMsgCtx
  120                           .getAxisService().getClassLoader());
  121               } else { // crypto props defined in a properties file
  122                   crypto = CryptoFactory.getInstance(config.cryptoPropertiesFile,
  123                           inMsgCtx.getAxisService().getClassLoader());
  124               }
  125   
  126               // Creation and expiration times
  127               Date creationTime = new Date();
  128               Date expirationTime = new Date();
  129               expirationTime.setTime(creationTime.getTime() + config.ttl);
  130   
  131               // Get the document
  132               Document doc = ((Element) env).getOwnerDocument();
  133   
  134               // Get the key size and create a new byte array of that size
  135               int keySize = data.getKeysize();
  136   
  137               keySize = (keySize == -1) ? config.keySize : keySize;
  138   
  139               /*
  140                * Find the KeyType If the KeyType is SymmetricKey or PublicKey,
  141                * issue a SAML HoK assertion. - In the case of the PublicKey, in
  142                * coming security header MUST contain a certificate (maybe via
  143                * signature)
  144                * 
  145                * If the KeyType is Bearer then issue a Bearer assertion
  146                * 
  147                * If the key type is missing we will issue a HoK assertion
  148                */
  149   
  150               String keyType = data.getKeyType();
  151               SAMLAssertion assertion;
  152               if (keyType == null) {
  153                   throw new TrustException(TrustException.INVALID_REQUEST,
  154                           new String[] { "Requested KeyType is missing" });
  155               }
  156   
  157               if (keyType.endsWith(RahasConstants.KEY_TYPE_SYMM_KEY)
  158                       || keyType.endsWith(RahasConstants.KEY_TYPE_PUBLIC_KEY)) {
  159                   assertion = createHoKAssertion(config, doc, crypto,
  160                           creationTime, expirationTime, data);
  161               } else if (keyType.endsWith(RahasConstants.KEY_TYPE_BEARER)) {
  162                   assertion = createBearerAssertion(config, doc, crypto,
  163                           creationTime, expirationTime, data);
  164               } else {
  165                   throw new TrustException("unsupportedKeyType");
  166               }
  167   
  168               OMElement rstrElem;
  169               int wstVersion = data.getVersion();
  170               if (RahasConstants.VERSION_05_02 == wstVersion) {
  171                   rstrElem = TrustUtil.createRequestSecurityTokenResponseElement(
  172                           wstVersion, env.getBody());
  173               } else {
  174                   OMElement rstrcElem = TrustUtil
  175                           .createRequestSecurityTokenResponseCollectionElement(
  176                                   wstVersion, env.getBody());
  177                   rstrElem = TrustUtil.createRequestSecurityTokenResponseElement(
  178                           wstVersion, rstrcElem);
  179               }
  180   
  181               TrustUtil.createTokenTypeElement(wstVersion, rstrElem).setText(
  182                       RahasConstants.TOK_TYPE_SAML_10);
  183   
  184               if (keyType.endsWith(RahasConstants.KEY_TYPE_SYMM_KEY)) {
  185                   TrustUtil.createKeySizeElement(wstVersion, rstrElem, keySize);
  186               }
  187   
  188               if (config.addRequestedAttachedRef) {
  189                   TrustUtil.createRequestedAttachedRef(wstVersion, rstrElem, "#"
  190                           + assertion.getId(), RahasConstants.TOK_TYPE_SAML_10);
  191               }
  192   
  193               if (config.addRequestedUnattachedRef) {
  194                   TrustUtil.createRequestedUnattachedRef(wstVersion, rstrElem,
  195                           assertion.getId(), RahasConstants.TOK_TYPE_SAML_10);
  196               }
  197   
  198               if (data.getAppliesToAddress() != null) {
  199                   TrustUtil.createAppliesToElement(rstrElem, data
  200                           .getAppliesToAddress(), data.getAddressingNs());
  201               }
  202   
  203               // Use GMT time in milliseconds
  204               DateFormat zulu = new XmlSchemaDateFormat();
  205   
  206               // Add the Lifetime element
  207               TrustUtil.createLifetimeElement(wstVersion, rstrElem, zulu
  208                       .format(creationTime), zulu.format(expirationTime));
  209   
  210               // Create the RequestedSecurityToken element and add the SAML token
  211               // to it
  212               OMElement reqSecTokenElem = TrustUtil
  213                       .createRequestedSecurityTokenElement(wstVersion, rstrElem);
  214               Token assertionToken;
  215               try {
  216                   Node tempNode = assertion.toDOM();
  217                   reqSecTokenElem.addChild((OMNode) ((Element) rstrElem)
  218                           .getOwnerDocument().importNode(tempNode, true));
  219   
  220                   // Store the token
  221                   assertionToken = new Token(assertion.getId(),
  222                           (OMElement) assertion.toDOM(), creationTime,
  223                           expirationTime);
  224   
  225                   // At this point we definitely have the secret
  226                   // Otherwise it should fail with an exception earlier
  227                   assertionToken.setSecret(data.getEphmeralKey());
  228                   TrustUtil.getTokenStore(inMsgCtx).add(assertionToken);
  229   
  230               } catch (SAMLException e) {
  231                   throw new TrustException("samlConverstionError", e);
  232               }
  233   
  234               if (keyType.endsWith(RahasConstants.KEY_TYPE_SYMM_KEY)
  235                       && config.keyComputation != SAMLTokenIssuerConfig.KeyComputation.KEY_COMP_USE_REQ_ENT) {
  236   
  237                   // Add the RequestedProofToken
  238                   TokenIssuerUtil.handleRequestedProofToken(data, wstVersion,
  239                           config, rstrElem, assertionToken, doc);
  240               }
  241   
  242               return env;
  243           } finally {
  244               // Unset the DOM impl to default
  245               DocumentBuilderFactoryImpl.setDOOMRequired(false);
  246           }
  247   
  248       }
  249   
  250       private SAMLAssertion createBearerAssertion(SAMLTokenIssuerConfig config,
  251               Document doc, Crypto crypto, Date creationTime,
  252               Date expirationTime, RahasData data) throws TrustException {
  253           try {
  254               Principal principal = data.getPrincipal();
  255               // In the case where the principal is a UT
  256               if (principal instanceof WSUsernameTokenPrincipal) {
  257               	SAMLNameIdentifier nameId = null;
  258               	if(config.getCallbackHander() != null){
  259               		SAMLNameIdentifierCallback cb = new SAMLNameIdentifierCallback(data);
  260               		cb.setUserId(principal.getName());
  261               		SAMLCallbackHandler callbackHandler = config.getCallbackHander();
  262               		callbackHandler.handle(cb);
  263               		nameId = cb.getNameId();
  264               	}else{
  265                 		nameId = new SAMLNameIdentifier(
  266               		principal.getName(), null, SAMLNameIdentifier.FORMAT_EMAIL);
  267               	}
  268               	
  269                   return createAuthAssertion(doc, SAMLSubject.CONF_BEARER,
  270                           nameId, null, config, crypto, creationTime,
  271                           expirationTime);
  272               } else {
  273                   throw new TrustException("samlUnsupportedPrincipal",
  274                           new String[] { principal.getClass().getName() });
  275               }
  276           } catch (SAMLException e) {
  277               throw new TrustException("samlAssertionCreationError", e);
  278           }
  279       }
  280   
  281       private SAMLAssertion createHoKAssertion(SAMLTokenIssuerConfig config,
  282               Document doc, Crypto crypto, Date creationTime,
  283               Date expirationTime, RahasData data) throws TrustException {
  284   
  285           if (data.getKeyType().endsWith(RahasConstants.KEY_TYPE_SYMM_KEY)) {
  286               Element encryptedKeyElem;
  287               X509Certificate serviceCert = null;
  288               try {
  289   
  290                   // Get ApliesTo to figure out which service to issue the token
  291                   // for
  292                   serviceCert = getServiceCert(config, crypto, data
  293                           .getAppliesToAddress());
  294   
  295                   // Create the encrypted key
  296                   WSSecEncryptedKey encrKeyBuilder = new WSSecEncryptedKey();
  297   
  298                   // Use thumbprint id
  299                   encrKeyBuilder
  300                           .setKeyIdentifierType(WSConstants.THUMBPRINT_IDENTIFIER);
  301   
  302                   // SEt the encryption cert
  303                   encrKeyBuilder.setUseThisCert(serviceCert);
  304   
  305                   // set keysize
  306                   int keysize = data.getKeysize();
  307                   keysize = (keysize != -1) ? keysize : config.keySize;
  308                   encrKeyBuilder.setKeySize(keysize);
  309   
  310                   encrKeyBuilder.setEphemeralKey(TokenIssuerUtil.getSharedSecret(
  311                           data, config.keyComputation, keysize));
  312   
  313                   // Set key encryption algo
  314                   encrKeyBuilder
  315                           .setKeyEncAlgo(EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15);
  316   
  317                   // Build
  318                   encrKeyBuilder.prepare(doc, crypto);
  319   
  320                   // Extract the base64 encoded secret value
  321                   byte[] tempKey = new byte[keysize / 8];
  322                   System.arraycopy(encrKeyBuilder.getEphemeralKey(), 0, tempKey,
  323                           0, keysize / 8);
  324   
  325                   data.setEphmeralKey(tempKey);
  326   
  327                   // Extract the Encryptedkey DOM element
  328                   encryptedKeyElem = encrKeyBuilder.getEncryptedKeyElement();
  329               } catch (WSSecurityException e) {
  330                   throw new TrustException(
  331                           "errorInBuildingTheEncryptedKeyForPrincipal",
  332                           new String[] { serviceCert.getSubjectDN().getName() },
  333                           e);
  334               }
  335               return this.createAttributeAssertion(doc, data ,encryptedKeyElem, config,
  336                       crypto, creationTime, expirationTime);
  337           } else {
  338               try {
  339                   String subjectNameId = data.getPrincipal().getName();
  340                   
  341                   SAMLNameIdentifier nameId = new SAMLNameIdentifier(
  342                           subjectNameId, null, SAMLNameIdentifier.FORMAT_EMAIL);
  343   
  344                   // Create the ds:KeyValue element with the ds:X509Data
  345                   X509Certificate clientCert = data.getClientCert();
  346   
  347                   if(clientCert == null) {
  348                       X509Certificate[] certs = crypto.getCertificates(
  349                               data.getPrincipal().getName());
  350                       clientCert = certs[0];
  351                   }
  352   
  353                   byte[] clientCertBytes = clientCert.getEncoded();
  354   
  355                   String base64Cert = Base64.encode(clientCertBytes);
  356   
  357                   Text base64CertText = doc.createTextNode(base64Cert);
  358                   Element x509CertElem = doc.createElementNS(WSConstants.SIG_NS,
  359                           "X509Certificate");
  360                   x509CertElem.appendChild(base64CertText);
  361                   Element x509DataElem = doc.createElementNS(WSConstants.SIG_NS,
  362                           "X509Data");
  363                   x509DataElem.appendChild(x509CertElem);
  364   
  365                   return this.createAuthAssertion(doc,
  366                           SAMLSubject.CONF_HOLDER_KEY, nameId, x509DataElem,
  367                           config, crypto, creationTime, expirationTime);
  368               } catch (Exception e) {
  369                   throw new TrustException("samlAssertionCreationError", e);
  370               }
  371           }
  372       }
  373   
  374       /**
  375        * Uses the <code>wst:AppliesTo</code> to figure out the certificate to
  376        * encrypt the secret in the SAML token
  377        * 
  378        * @param config
  379        * @param crypto
  380        * @param serviceAddress
  381        *            The address of the service
  382        * @return
  383        * @throws WSSecurityException
  384        */
  385       private X509Certificate getServiceCert(SAMLTokenIssuerConfig config,
  386               Crypto crypto, String serviceAddress) throws WSSecurityException {
  387           
  388           if (serviceAddress != null && !"".equals(serviceAddress)) {
  389               String alias = (String) config.trustedServices.get(serviceAddress);
  390               if (alias != null) {
  391                   return crypto.getCertificates(alias)[0];
  392               } else {
  393                   alias = (String) config.trustedServices.get("*");
  394                   return crypto.getCertificates(alias)[0];
  395               }
  396           } else {
  397               String alias = (String) config.trustedServices.get("*");
  398               return crypto.getCertificates(alias)[0];
  399           }
  400   
  401       }
  402   
  403       /**
  404        * Create the SAML assertion with the secret held in an
  405        * <code>xenc:EncryptedKey</code>
  406        * 
  407        * @param doc
  408        * @param keyInfoContent
  409        * @param config
  410        * @param crypto
  411        * @param notBefore
  412        * @param notAfter
  413        * @return
  414        * @throws TrustException
  415        */
  416       private SAMLAssertion createAttributeAssertion(Document doc, RahasData data,
  417               Element keyInfoContent, SAMLTokenIssuerConfig config,
  418               Crypto crypto, Date notBefore, Date notAfter) throws TrustException {
  419           try {
  420               String[] confirmationMethods = new String[] { SAMLSubject.CONF_HOLDER_KEY };
  421   
  422               Element keyInfoElem = doc.createElementNS(WSConstants.SIG_NS,
  423                       "KeyInfo");
  424               ((OMElement) keyInfoContent).declareNamespace(WSConstants.SIG_NS,
  425                       WSConstants.SIG_PREFIX);
  426               ((OMElement) keyInfoContent).declareNamespace(WSConstants.ENC_NS,
  427                       WSConstants.ENC_PREFIX);
  428   
  429               keyInfoElem.appendChild(keyInfoContent);
  430   
  431               SAMLSubject subject = new SAMLSubject(null, Arrays
  432                       .asList(confirmationMethods), null, keyInfoElem);
  433   
  434              
  435               SAMLAttribute[] attrs = null;
  436               if(config.getCallbackHander() != null){
  437               	SAMLAttributeCallback cb = new SAMLAttributeCallback(data);
  438               	SAMLCallbackHandler handler = config.getCallbackHander();
  439               	handler.handle(cb);
  440               	attrs = cb.getAttributes();
  441               }else{
  442               	//TODO Remove this after discussing
  443                   SAMLAttribute attribute = new SAMLAttribute("Name",
  444                           "https://rahas.apache.org/saml/attrns", null, -1, Arrays
  445                                   .asList(new String[] { "Colombo/Rahas" }));
  446                   attrs = new SAMLAttribute[]{attribute};
  447               }
  448               
  449               SAMLAttributeStatement attrStmt = new SAMLAttributeStatement(
  450               subject, Arrays.asList(attrs ));
  451   
  452               SAMLStatement[] statements = { attrStmt };
  453   
  454               SAMLAssertion assertion = new SAMLAssertion(config.issuerName,
  455                       notBefore, notAfter, null, null, Arrays.asList(statements));
  456   
  457               // sign the assertion
  458               X509Certificate[] issuerCerts = crypto
  459                       .getCertificates(config.issuerKeyAlias);
  460   
  461               String sigAlgo = XMLSignature.ALGO_ID_SIGNATURE_RSA;
  462               String pubKeyAlgo = issuerCerts[0].getPublicKey().getAlgorithm();
  463               if (pubKeyAlgo.equalsIgnoreCase("DSA")) {
  464                   sigAlgo = XMLSignature.ALGO_ID_SIGNATURE_DSA;
  465               }
  466               java.security.Key issuerPK = crypto.getPrivateKey(
  467                       config.issuerKeyAlias, config.issuerKeyPassword);
  468               assertion.sign(sigAlgo, issuerPK, Arrays.asList(issuerCerts));
  469   
  470               return assertion;
  471           } catch (Exception e) {
  472               throw new TrustException("samlAssertionCreationError", e);
  473           }
  474       }
  475   
  476       /**
  477        * @param doc
  478        * @param confMethod
  479        * @param subjectNameId
  480        * @param keyInfoContent
  481        * @param config
  482        * @param crypto
  483        * @param notBefore
  484        * @param notAfter
  485        * @return
  486        * @throws TrustException
  487        */
  488       private SAMLAssertion createAuthAssertion(Document doc, String confMethod,
  489               SAMLNameIdentifier subjectNameId, Element keyInfoContent,
  490               SAMLTokenIssuerConfig config, Crypto crypto, Date notBefore,
  491               Date notAfter) throws TrustException {
  492           try {
  493               String[] confirmationMethods = new String[] { confMethod };
  494   
  495               Element keyInfoElem = null;
  496               if (keyInfoContent != null) {
  497                   keyInfoElem = doc
  498                           .createElementNS(WSConstants.SIG_NS, "KeyInfo");
  499                   ((OMElement) keyInfoContent).declareNamespace(
  500                           WSConstants.SIG_NS, WSConstants.SIG_PREFIX);
  501                   ((OMElement) keyInfoContent).declareNamespace(
  502                           WSConstants.ENC_NS, WSConstants.ENC_PREFIX);
  503   
  504                   keyInfoElem.appendChild(keyInfoContent);
  505               }
  506   
  507               SAMLSubject subject = new SAMLSubject(subjectNameId, Arrays
  508                       .asList(confirmationMethods), null, keyInfoElem);
  509   
  510               SAMLAuthenticationStatement authStmt = new SAMLAuthenticationStatement(
  511                       subject,
  512                       SAMLAuthenticationStatement.AuthenticationMethod_Password,
  513                       notBefore, null, null, null);
  514               SAMLStatement[] statements = { authStmt };
  515   
  516               SAMLAssertion assertion = new SAMLAssertion(config.issuerName,
  517                       notBefore, notAfter, null, null, Arrays.asList(statements));
  518   
  519               // sign the assertion
  520               X509Certificate[] issuerCerts = crypto
  521                       .getCertificates(config.issuerKeyAlias);
  522   
  523               String sigAlgo = XMLSignature.ALGO_ID_SIGNATURE_RSA;
  524               String pubKeyAlgo = issuerCerts[0].getPublicKey().getAlgorithm();
  525               if (pubKeyAlgo.equalsIgnoreCase("DSA")) {
  526                   sigAlgo = XMLSignature.ALGO_ID_SIGNATURE_DSA;
  527               }
  528               java.security.Key issuerPK = crypto.getPrivateKey(
  529                       config.issuerKeyAlias, config.issuerKeyPassword);
  530               assertion.sign(sigAlgo, issuerPK, Arrays.asList(issuerCerts));
  531   
  532               return assertion;
  533           } catch (Exception e) {
  534               throw new TrustException("samlAssertionCreationError", e);
  535           }
  536       }
  537   
  538       /**
  539        * {@inheritDoc}
  540        */
  541       public String getResponseAction(RahasData data) throws TrustException {
  542           return TrustUtil.getActionValue(data.getVersion(),
  543                   RahasConstants.RSTR_ACTION_ISSUE);
  544       }
  545   
  546       /**
  547        * Create an ephemeral key
  548        * 
  549        * @return The generated key as a byte array
  550        * @throws TrustException
  551        */
  552       protected byte[] generateEphemeralKey(int keySize) throws TrustException {
  553           try {
  554               SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
  555               byte[] temp = new byte[keySize / 8];
  556               random.nextBytes(temp);
  557               return temp;
  558           } catch (Exception e) {
  559               throw new TrustException("Error in creating the ephemeral key", e);
  560           }
  561       }
  562   
  563       /**
  564        * {@inheritDoc}
  565        */
  566       public void setConfigurationFile(String configFile) {
  567           this.configFile = configFile;
  568   
  569       }
  570       
  571       /**
  572        * {@inheritDoc}
  573        */
  574       public void setConfigurationElement(OMElement configElement) {
  575           this.configElement = configElement;
  576       }
  577   
  578       /**
  579        * {@inheritDoc}
  580        */
  581       public void setConfigurationParamName(String configParamName) {
  582           this.configParamName = configParamName;
  583       }
  584   
  585   }

Save This Page
Home » rampart-dist-1.4-src » org.apache » rahas » impl » [javadoc | source]