/**
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements. See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership. The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at
    *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied. See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package org.apache.wss4j.dom.handler;
  
  import java.security.Provider;
  import java.security.cert.Certificate;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Pattern;
  
  import javax.security.auth.callback.CallbackHandler;
  import javax.xml.namespace.QName;
  
  import org.apache.wss4j.common.ConfigurationConstants;
  import org.apache.wss4j.common.EncryptionActionToken;
  import org.apache.wss4j.common.SignatureActionToken;
  import org.apache.wss4j.common.bsp.BSPEnforcer;
  import org.apache.wss4j.common.bsp.BSPRule;
  import org.apache.wss4j.common.cache.ReplayCache;
  import org.apache.wss4j.common.crypto.AlgorithmSuite;
  import org.apache.wss4j.common.crypto.Crypto;
  import org.apache.wss4j.common.crypto.PasswordEncryptor;
  import org.apache.wss4j.common.ext.WSSecurityException;
  import org.apache.wss4j.dom.SOAPConstants;
  import org.apache.wss4j.dom.WSConstants;
  import org.apache.wss4j.dom.WSDocInfo;
  import org.apache.wss4j.dom.engine.WSSConfig;
  import org.apache.wss4j.dom.message.WSSecHeader;
  import org.apache.wss4j.dom.validate.Validator;
  import org.apache.xml.security.encryption.Serializer;
  
  /**
   * This class holds per request data.
   */
  public class RequestData {
  
      private Object msgContext;
      private SOAPConstants soapConstants;
      private String actor;
      private String username;
      private String pwType = WSConstants.PASSWORD_DIGEST; // Make this the default when no password type is given.
      private Crypto sigVerCrypto;
      private Crypto decCrypto;
      private SignatureActionToken signatureToken;
      private EncryptionActionToken encryptionToken;
      private WSSConfig wssConfig;
      private List<byte[]> signatureValues = new ArrayList<>();
      private WSSecHeader secHeader;
      private int derivedKeyIterations = 1000;
      private boolean useDerivedKeyForMAC = true;
      private CallbackHandler callback;
      private CallbackHandler attachmentCallbackHandler;
      private boolean enableRevocation;
      private boolean requireSignedEncryptedDataElements;
      private ReplayCache timestampReplayCache;
      private ReplayCache nonceReplayCache;
      private ReplayCache samlOneTimeUseReplayCache;
      private Collection<Pattern> subjectDNPatterns = new ArrayList<>();
      private Collection<Pattern> issuerDNPatterns = new ArrayList<>();
      private final List<BSPRule> ignoredBSPRules = new LinkedList<>();
      private boolean appendSignatureAfterTimestamp;
      private int originalSignatureActionPosition;
      private AlgorithmSuite algorithmSuite;
      private AlgorithmSuite samlAlgorithmSuite;
      private boolean disableBSPEnforcement;
      private boolean allowRSA15KeyTransportAlgorithm;
      private int processorNestingDepth;
      private boolean addUsernameTokenNonce;
      private boolean addUsernameTokenCreated;
      private Certificate[] tlsCerts;
      private PasswordEncryptor passwordEncryptor;
      private String derivedKeyTokenReference;
      private boolean use200512Namespace = true;
      private final List<String> audienceRestrictions = new ArrayList<>();
      private boolean requireTimestampExpires;
      private boolean storeBytesInAttachment;
      private Serializer encryptionSerializer;
      private WSDocInfo wsDocInfo;
      private Provider signatureProvider;
 
     /**
      * Whether to add an InclusiveNamespaces PrefixList as a CanonicalizationMethod
      * child when generating Signatures using WSConstants.C14N_EXCL_OMIT_COMMENTS.
      * The default is true.
      */
     private boolean addInclusivePrefixes = true;
 
     /**
      * Set the timestamp precision mode. If set to <code>true</code> then use
      * timestamps with milliseconds, otherwise omit the milliseconds. As per XML
      * Date/Time specification the default is to include the milliseconds.
      */
     private boolean precisionInMilliSeconds = true;
 
     private boolean enableSignatureConfirmation;
 
     /**
      * If set to true then the timestamp handling will throw an exception if the
      * timestamp contains an expires element and the semantics are expired.
      *
      * If set to false, no exception will be thrown, even if the semantics are
      * expired.
      */
     private boolean timeStampStrict = true;
 
     /**
      * If this value is not null, then username token handling will throw an
      * exception if the password type of the Username Token does not match this value
      */
     private String requiredPasswordType;
 
     /**
      * This variable controls whether a UsernameToken with no password element is allowed.
      * The default value is "false". Set it to "true" to allow deriving keys from UsernameTokens
      * or to support UsernameTokens for purposes other than authentication.
      */
     private boolean allowUsernameTokenNoPassword;
 
     /**
      * The time in seconds between creation and expiry for a Timestamp. The default
      * is 300 seconds (5 minutes).
      */
     private int timeStampTTL = 300;
 
     /**
      * The time in seconds in the future within which the Created time of an incoming
      * Timestamp is valid. The default is 60 seconds.
      */
     private int timeStampFutureTTL = 60;
 
     /**
      * The time in seconds between creation and expiry for a UsernameToken Created
      * element. The default is 300 seconds (5 minutes).
      */
     private int utTTL = 300;
 
     /**
      * The time in seconds in the future within which the Created time of an incoming
      * UsernameToken is valid. The default is 60 seconds.
      */
     private int utFutureTTL = 60;
 
     /**
      * This variable controls whether types other than PasswordDigest or PasswordText
      * are allowed when processing UsernameTokens.
      *
      * By default this is set to false so that the user doesn't have to explicitly
      * reject custom token types in the callback handler.
      */
     private boolean handleCustomPasswordTypes;
 
     /**
      * This variable controls whether (wsse) namespace qualified password types are
      * accepted when processing UsernameTokens.
      *
      * By default this is set to false.
      */
     private boolean allowNamespaceQualifiedPasswordTypes;
 
     /**
      * Whether the password should be treated as a binary value.  This
      * is needed to properly handle password equivalence for UsernameToken
      * passwords.  Binary passwords are Base64 encoded so they can be
      * treated as strings in most places, but when the password digest
      * is calculated or a key is derived from the password, the password
      * will be Base64 decoded before being used. This is most useful for
      * hashed passwords as password equivalents.
      *
      * See https://issues.apache.org/jira/browse/WSS-239
      */
     private boolean encodePasswords;
 
     /**
      * Whether to validate the SubjectConfirmation requirements of a received SAML Token
      * (sender-vouches or holder-of-key). The default is true.
      */
     private boolean validateSamlSubjectConfirmation = true;
 
     private boolean expandXopInclude;
 
     public Object getMsgContext() {
         return msgContext;
     }
 
     public void setMsgContext(Object msgContext) {
         this.msgContext = msgContext;
     }
 
     public SOAPConstants getSoapConstants() {
         return soapConstants;
     }
 
     public void setSoapConstants(SOAPConstants soapConstants) {
         this.soapConstants = soapConstants;
     }
 
     public String getActor() {
         return actor;
     }
 
     public void setActor(String actor) {
         this.actor = actor;
     }
 
     public String getUsername() {
         return username;
     }
 
     public void setUsername(String username) {
         this.username = username;
     }
 
     public String getPwType() {
         return pwType;
     }
 
     public void setPwType(String pwType) {
         this.pwType = pwType;
     }
 
     public Crypto getSigVerCrypto() {
         return sigVerCrypto;
     }
 
     public void setSigVerCrypto(Crypto sigVerCrypto) {
         this.sigVerCrypto = sigVerCrypto;
     }
 
     public Crypto getDecCrypto() {
         return decCrypto;
     }
 
     public void setDecCrypto(Crypto decCrypto) {
         this.decCrypto = decCrypto;
     }
 
     /**
      * @return Returns the wssConfig.
      */
     public WSSConfig getWssConfig() {
         return wssConfig;
     }
 
     /**
      * @param wssConfig The wssConfig to set.
      */
     public void setWssConfig(WSSConfig wssConfig) {
         this.wssConfig = wssConfig;
     }
 
     /**
      * @return Returns the list of stored signature values.
      */
     public List<byte[]> getSignatureValues() {
         return signatureValues;
     }
 
     /**
      * @return Returns the secHeader.
      */
     public WSSecHeader getSecHeader() {
         return secHeader;
     }
 
     /**
      * @param secHeader The secHeader to set.
      */
     public void setSecHeader(WSSecHeader secHeader) {
         this.secHeader = secHeader;
     }
 
     /**
      * Set the derived key iterations. Default is 1000.
      * @param iterations The number of iterations to use when deriving a key
      */
     public void setDerivedKeyIterations(int iterations) {
         derivedKeyIterations = iterations;
     }
 
     /**
      * Get the derived key iterations.
      * @return The number of iterations to use when deriving a key
      */
     public int getDerivedKeyIterations() {
         return derivedKeyIterations;
     }
 
     /**
      * Whether to use the derived key for a MAC.
      * @param useMac Whether to use the derived key for a MAC.
      */
     public void setUseDerivedKeyForMAC(boolean useMac) {
         useDerivedKeyForMAC = useMac;
     }
 
     /**
      * Whether to use the derived key for a MAC.
      * @return Whether to use the derived key for a MAC.
      */
     public boolean isUseDerivedKeyForMAC() {
         return useDerivedKeyForMAC;
     }
 
     /**
      * Set whether to enable CRL checking or not when verifying trust in a certificate.
      * @param enableRevocation whether to enable CRL checking
      */
     public void setEnableRevocation(boolean enableRevocation) {
         this.enableRevocation = enableRevocation;
     }
 
     /**
      * Get whether to enable CRL checking or not when verifying trust in a certificate.
      * @return whether to enable CRL checking
      */
     public boolean isRevocationEnabled() {
         return enableRevocation;
     }
 
     /**
      * @return whether EncryptedData elements are required to be signed
      */
     public boolean isRequireSignedEncryptedDataElements() {
         return requireSignedEncryptedDataElements;
     }
 
     /**
      * Configure the engine to verify that EncryptedData elements
      * are in a signed subtree of the document. This can be used to
      * prevent some wrapping based attacks when encrypt-before-sign
      * token protection is selected.
      *
      * @param requireSignedEncryptedDataElements
      */
     public void setRequireSignedEncryptedDataElements(boolean requireSignedEncryptedDataElements) {
         this.requireSignedEncryptedDataElements = requireSignedEncryptedDataElements;
     }
 
     /**
      * Sets the CallbackHandler used for this request
      * @param cb
      */
     public void setCallbackHandler(CallbackHandler cb) {
         callback = cb;
     }
 
     /**
      * Returns the CallbackHandler used for this request.
      * @return the CallbackHandler used for this request.
      */
     public CallbackHandler getCallbackHandler() {
         return callback;
     }
 
     public CallbackHandler getAttachmentCallbackHandler() {
         return attachmentCallbackHandler;
     }
 
     public void setAttachmentCallbackHandler(CallbackHandler attachmentCallbackHandler) {
         this.attachmentCallbackHandler = attachmentCallbackHandler;
     }
 
     /**
      * Get the Validator instance corresponding to the QName
      * @param qName the QName with which to find a Validator instance
      * @return the Validator instance corresponding to the QName
      * @throws WSSecurityException
      */
     public Validator getValidator(QName qName) throws WSSecurityException {
         // Check the custom Validator Map first
         if (getMsgContext() instanceof Map<?,?>) {
             @SuppressWarnings("unchecked")
             Map<QName, Validator> validatorMap =
                 (Map<QName, Validator>)((Map<?,?>)getMsgContext()).get(ConfigurationConstants.VALIDATOR_MAP);
             if (validatorMap != null && validatorMap.containsKey(qName)) {
                 return validatorMap.get(qName);
             }
         }
         if (wssConfig != null) {
             return wssConfig.getValidator(qName);
         }
         return null;
     }
 
     /**
      * Set the replay cache for Timestamps
      */
     public void setTimestampReplayCache(ReplayCache newCache) {
         timestampReplayCache = newCache;
     }
 
     /**
      * Get the replay cache for Timestamps
      * @throws WSSecurityException
      */
     public ReplayCache getTimestampReplayCache() throws WSSecurityException {
         return timestampReplayCache;
     }
 
     /**
      * Set the replay cache for Nonces
      */
     public void setNonceReplayCache(ReplayCache newCache) {
         nonceReplayCache = newCache;
     }
 
     /**
      * Get the replay cache for Nonces
      * @throws WSSecurityException
      */
     public ReplayCache getNonceReplayCache() throws WSSecurityException {
         return nonceReplayCache;
     }
 
     /**
      * Set the replay cache for SAML2 OneTimeUse Assertions
      */
     public void setSamlOneTimeUseReplayCache(ReplayCache newCache) {
         samlOneTimeUseReplayCache = newCache;
     }
 
     /**
      * Get the replay cache for SAML2 OneTimeUse Assertions
      * @throws WSSecurityException
      */
     public ReplayCache getSamlOneTimeUseReplayCache() throws WSSecurityException {
         return samlOneTimeUseReplayCache;
     }
 
     /**
      * Set the Signature Subject Cert Constraints
      */
     public void setSubjectCertConstraints(Collection<Pattern> subjectCertConstraints) {
         if (subjectCertConstraints != null) {
             subjectDNPatterns.addAll(subjectCertConstraints);
         }
     }
 
     /**
      * Get the Signature Subject Cert Constraints
      */
     public Collection<Pattern> getSubjectCertConstraints() {
         return subjectDNPatterns;
     }
 
     /**
      * Get the Signature Issuer DN Cert Constraints
      * @return
      */
     public Collection<Pattern> getIssuerDNPatterns() {
         return issuerDNPatterns;
     }
     /**
      * Set the Signature Issuer DN Cert Constraints
      *
      */
     public void setIssuerDNPatterns(Collection<Pattern> issuerDNPatterns) {
         this.issuerDNPatterns = issuerDNPatterns;
     }
 
     /**
      * Set the Audience Restrictions
      */
     public void setAudienceRestrictions(List<String> audienceRestrictions) {
         if (audienceRestrictions != null) {
             this.audienceRestrictions.addAll(audienceRestrictions);
         }
     }
 
     /**
      * Get the Audience Restrictions
      */
     public List<String> getAudienceRestrictions() {
         return audienceRestrictions;
     }
 
     public void setIgnoredBSPRules(List<BSPRule> bspRules) {
         ignoredBSPRules.clear();
         ignoredBSPRules.addAll(bspRules);
     }
 
     public BSPEnforcer getBSPEnforcer() {
         if (disableBSPEnforcement) {
             return new BSPEnforcer(true);
         }
         return new BSPEnforcer(ignoredBSPRules);
     }
 
     public boolean isAppendSignatureAfterTimestamp() {
         return appendSignatureAfterTimestamp;
     }
 
     public void setAppendSignatureAfterTimestamp(boolean appendSignatureAfterTimestamp) {
         this.appendSignatureAfterTimestamp = appendSignatureAfterTimestamp;
     }
 
     public AlgorithmSuite getAlgorithmSuite() {
         return algorithmSuite;
     }
 
     public void setAlgorithmSuite(AlgorithmSuite algorithmSuite) {
         this.algorithmSuite = algorithmSuite;
     }
 
     public AlgorithmSuite getSamlAlgorithmSuite() {
         return samlAlgorithmSuite;
     }
 
     public void setSamlAlgorithmSuite(AlgorithmSuite samlAlgorithmSuite) {
         this.samlAlgorithmSuite = samlAlgorithmSuite;
     }
 
     public int getOriginalSignatureActionPosition() {
         return originalSignatureActionPosition;
     }
 
     public void setOriginalSignatureActionPosition(int originalSignatureActionPosition) {
         this.originalSignatureActionPosition = originalSignatureActionPosition;
     }
 
     public boolean isDisableBSPEnforcement() {
         return disableBSPEnforcement;
     }
 
     public void setDisableBSPEnforcement(boolean disableBSPEnforcement) {
         this.disableBSPEnforcement = disableBSPEnforcement;
     }
 
     /**
      * The maximum depth to which a processor may hand a token it has just uncovered to another
      * processor. Decrypting an EncryptedData whose plaintext is itself a security structure does
      * exactly that, and does it recursively, so a sender who nests those structures is choosing
      * how much of the receiver's stack to consume. Each level costs very little to write - every
      * one of them may point its KeyInfo at a single EncryptedKey, which is decrypted once and
      * cached - so the chain has to be bounded.
      * <p/>
      * Real messages stay well inside this. An EncryptedAssertion reaches depth 2: the assertion's
      * EncryptedData, then the decrypted Assertion handed to the SAML processor, which dispatches
      * no further. Re-encrypting an already encrypted assertion reaches 3. Sibling tokens in the
      * same header do not accumulate - each is entered and left in turn - so the bound constrains
      * nesting only.
      */
     public static final int MAXIMUM_PROCESSOR_NESTING_DEPTH = 5;
 
     /**
      * Record that processing is about to descend into a token uncovered by another token, and
      * refuse to go deeper than {@link #MAXIMUM_PROCESSOR_NESTING_DEPTH}. Every caller must pair
      * this with {@link #exitNestedToken()} in a finally block.
      *
      * @throws WSSecurityException if the message nests tokens too deeply
      */
     public void enterNestedToken() throws WSSecurityException {
         if (processorNestingDepth >= MAXIMUM_PROCESSOR_NESTING_DEPTH) {
             throw new WSSecurityException(
                 WSSecurityException.ErrorCode.INVALID_SECURITY, "empty",
                 new Object[] {"Tokens are nested more than "
                               + MAXIMUM_PROCESSOR_NESTING_DEPTH + " deep"});
         }
         processorNestingDepth++;
     }
 
     /**
      * Record that processing has come back out of a nested token.
      */
     public void exitNestedToken() {
         processorNestingDepth--;
     }
 
     public boolean isAllowRSA15KeyTransportAlgorithm() {
         return allowRSA15KeyTransportAlgorithm;
     }
 
     public void setAllowRSA15KeyTransportAlgorithm(boolean allowRSA15KeyTransportAlgorithm) {
         this.allowRSA15KeyTransportAlgorithm = allowRSA15KeyTransportAlgorithm;
     }
 
     public Certificate[] getTlsCerts() {
         return tlsCerts;
     }
 
     public void setTlsCerts(Certificate[] tlsCerts) {
         this.tlsCerts = tlsCerts;
     }
 
     public PasswordEncryptor getPasswordEncryptor() {
         return passwordEncryptor;
     }
 
     public void setPasswordEncryptor(PasswordEncryptor passwordEncryptor) {
         this.passwordEncryptor = passwordEncryptor;
     }
 
     public SignatureActionToken getSignatureToken() {
         return signatureToken;
     }
 
     public void setSignatureToken(SignatureActionToken signatureToken) {
         this.signatureToken = signatureToken;
     }
 
     public EncryptionActionToken getEncryptionToken() {
         return encryptionToken;
     }
 
     public void setEncryptionToken(EncryptionActionToken encryptionToken) {
         this.encryptionToken = encryptionToken;
     }
 
     public String getDerivedKeyTokenReference() {
         return derivedKeyTokenReference;
     }
 
     public void setDerivedKeyTokenReference(String derivedKeyTokenReference) {
         this.derivedKeyTokenReference = derivedKeyTokenReference;
     }
 
     public boolean isUse200512Namespace() {
         return use200512Namespace;
     }
 
     public void setUse200512Namespace(boolean use200512Namespace) {
         this.use200512Namespace = use200512Namespace;
     }
 
     public boolean isRequireTimestampExpires() {
         return requireTimestampExpires;
     }
 
     public void setRequireTimestampExpires(boolean requireTimestampExpires) {
         this.requireTimestampExpires = requireTimestampExpires;
     }
 
     public boolean isValidateSamlSubjectConfirmation() {
         return validateSamlSubjectConfirmation;
     }
 
     public void setValidateSamlSubjectConfirmation(boolean validateSamlSubjectConfirmation) {
         this.validateSamlSubjectConfirmation = validateSamlSubjectConfirmation;
     }
 
     public boolean isAllowNamespaceQualifiedPasswordTypes() {
         return allowNamespaceQualifiedPasswordTypes;
     }
 
     public void setAllowNamespaceQualifiedPasswordTypes(boolean allowNamespaceQualifiedPasswordTypes) {
         this.allowNamespaceQualifiedPasswordTypes = allowNamespaceQualifiedPasswordTypes;
     }
 
     public int getUtFutureTTL() {
         return utFutureTTL;
     }
 
     public void setUtFutureTTL(int utFutureTTL) {
         this.utFutureTTL = utFutureTTL;
     }
 
     public boolean isHandleCustomPasswordTypes() {
         return handleCustomPasswordTypes;
     }
 
     public void setHandleCustomPasswordTypes(boolean handleCustomPasswordTypes) {
         this.handleCustomPasswordTypes = handleCustomPasswordTypes;
     }
 
     public int getUtTTL() {
         return utTTL;
     }
 
     public void setUtTTL(int utTTL) {
         this.utTTL = utTTL;
     }
 
     public int getTimeStampTTL() {
         return timeStampTTL;
     }
 
     public void setTimeStampTTL(int timeStampTTL) {
         this.timeStampTTL = timeStampTTL;
     }
 
     public int getTimeStampFutureTTL() {
         return timeStampFutureTTL;
     }
 
     public void setTimeStampFutureTTL(int timeStampFutureTTL) {
         this.timeStampFutureTTL = timeStampFutureTTL;
     }
 
     public boolean isAllowUsernameTokenNoPassword() {
         return allowUsernameTokenNoPassword;
     }
 
     public void setAllowUsernameTokenNoPassword(boolean allowUsernameTokenNoPassword) {
         this.allowUsernameTokenNoPassword = allowUsernameTokenNoPassword;
     }
 
     public boolean isTimeStampStrict() {
         return timeStampStrict;
     }
 
     public void setTimeStampStrict(boolean timeStampStrict) {
         this.timeStampStrict = timeStampStrict;
     }
 
     public boolean isAddInclusivePrefixes() {
         return addInclusivePrefixes;
     }
 
     public void setAddInclusivePrefixes(boolean addInclusivePrefixes) {
         this.addInclusivePrefixes = addInclusivePrefixes;
     }
 
     public boolean isPrecisionInMilliSeconds() {
         return precisionInMilliSeconds;
     }
 
     public void setPrecisionInMilliSeconds(boolean precisionInMilliSeconds) {
         this.precisionInMilliSeconds = precisionInMilliSeconds;
     }
 
     public boolean isEnableSignatureConfirmation() {
         return enableSignatureConfirmation;
     }
 
     public void setEnableSignatureConfirmation(boolean enableSignatureConfirmation) {
         this.enableSignatureConfirmation = enableSignatureConfirmation;
     }
 
     public String getRequiredPasswordType() {
         return requiredPasswordType;
     }
 
     public void setRequiredPasswordType(String requiredPasswordType) {
         this.requiredPasswordType = requiredPasswordType;
     }
 
     public boolean isEncodePasswords() {
         return encodePasswords;
     }
 
     public void setEncodePasswords(boolean encodePasswords) {
         this.encodePasswords = encodePasswords;
     }
 
     public boolean isStoreBytesInAttachment() {
         return storeBytesInAttachment;
     }
 
     public void setStoreBytesInAttachment(boolean storeBytesInAttachment) {
         this.storeBytesInAttachment = storeBytesInAttachment;
     }
 
     public boolean isExpandXopInclude() {
         return expandXopInclude;
     }
 
     public void setExpandXopInclude(boolean expandXopInclude) {
         this.expandXopInclude = expandXopInclude;
     }
 
     public Serializer getEncryptionSerializer() {
         return encryptionSerializer;
     }
 
     public void setEncryptionSerializer(Serializer encryptionSerializer) {
         this.encryptionSerializer = encryptionSerializer;
     }
 
     public boolean isAddUsernameTokenCreated() {
         return addUsernameTokenCreated;
     }
 
     public void setAddUsernameTokenCreated(boolean addUsernameTokenCreated) {
         this.addUsernameTokenCreated = addUsernameTokenCreated;
     }
 
     public boolean isAddUsernameTokenNonce() {
         return addUsernameTokenNonce;
     }
 
     public void setAddUsernameTokenNonce(boolean addUsernameTokenNonce) {
         this.addUsernameTokenNonce = addUsernameTokenNonce;
     }
 
     public WSDocInfo getWsDocInfo() {
         return wsDocInfo;
     }
 
     public void setWsDocInfo(WSDocInfo wsDocInfo) {
         this.wsDocInfo = wsDocInfo;
     }
 
     public Provider getSignatureProvider() {
         return signatureProvider;
     }
 
     /**
      * Set a security Provider instance to use for Signature
      */
     public void setSignatureProvider(Provider signatureProvider) {
         this.signatureProvider = signatureProvider;
     }
 }