org.apache.wss4j.policy.model.AlgorithmSuite Maven / Gradle / Ivy
/**
* 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.policy.model;
import org.apache.neethi.Assertion;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyComponent;
import org.apache.neethi.PolicyContainingAssertion;
import org.apache.wss4j.policy.SPConstants;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import java.util.*;
public class AlgorithmSuite extends AbstractSecurityAssertion implements PolicyContainingAssertion {
protected static final Map ALGORITHM_SUITE_TYPES = new HashMap<>();
private static final int MAX_SKL = 256;
private static final int MIN_AKL = 1024;
private static final int MAX_AKL = 4096;
static {
ALGORITHM_SUITE_TYPES.put("Basic256", new AlgorithmSuiteType(
"Basic256",
SPConstants.SHA1,
SPConstants.AES256,
SPConstants.KW_AES256,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L256,
SPConstants.P_SHA1_L192,
256, 192, 256,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic192", new AlgorithmSuiteType(
"Basic192",
SPConstants.SHA1,
SPConstants.AES192,
SPConstants.KW_AES192,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic128", new AlgorithmSuiteType(
"Basic128",
SPConstants.SHA1,
SPConstants.AES128,
SPConstants.KW_AES128,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L128,
SPConstants.P_SHA1_L128,
128, 128, 128,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("TripleDes", new AlgorithmSuiteType(
"TripleDes",
SPConstants.SHA1,
SPConstants.TRIPLE_DES,
SPConstants.KW_TRIPLE_DES,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic256Rsa15", new AlgorithmSuiteType(
"Basic256Rsa15",
SPConstants.SHA1,
SPConstants.AES256,
SPConstants.KW_AES256,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L256,
SPConstants.P_SHA1_L192,
256, 192, 256,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic192Rsa15", new AlgorithmSuiteType(
"Basic192Rsa15",
SPConstants.SHA1,
SPConstants.AES192,
SPConstants.KW_AES192,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic128Rsa15", new AlgorithmSuiteType(
"Basic128Rsa15",
SPConstants.SHA1,
SPConstants.AES128,
SPConstants.KW_AES128,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L128,
SPConstants.P_SHA1_L128,
128, 128, 128,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("TripleDesRsa15", new AlgorithmSuiteType(
"TripleDesRsa15",
SPConstants.SHA1,
SPConstants.TRIPLE_DES,
SPConstants.KW_TRIPLE_DES,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic256Sha256", new AlgorithmSuiteType(
"Basic256Sha256",
SPConstants.SHA256,
SPConstants.AES256,
SPConstants.KW_AES256,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L256,
SPConstants.P_SHA1_L192,
256, 192, 256,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic192Sha256", new AlgorithmSuiteType(
"Basic192Sha256",
SPConstants.SHA256,
SPConstants.AES192,
SPConstants.KW_AES192,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic128Sha256", new AlgorithmSuiteType(
"Basic128Sha256",
SPConstants.SHA256,
SPConstants.AES128,
SPConstants.KW_AES128,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L128,
SPConstants.P_SHA1_L128,
128, 128, 128,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("TripleDesSha256", new AlgorithmSuiteType(
"TripleDesSha256",
SPConstants.SHA256,
SPConstants.TRIPLE_DES,
SPConstants.KW_TRIPLE_DES,
SPConstants.KW_RSA_OAEP,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic256Sha256Rsa15", new AlgorithmSuiteType(
"Basic256Sha256Rsa15",
SPConstants.SHA256,
SPConstants.AES256,
SPConstants.KW_AES256,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L256,
SPConstants.P_SHA1_L192,
256, 192, 256,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic192Sha256Rsa15", new AlgorithmSuiteType(
"Basic192Sha256Rsa15",
SPConstants.SHA256,
SPConstants.AES192,
SPConstants.KW_AES192,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("Basic128Sha256Rsa15", new AlgorithmSuiteType(
"Basic128Sha256Rsa15",
SPConstants.SHA256,
SPConstants.AES128,
SPConstants.KW_AES128,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L128,
SPConstants.P_SHA1_L128,
128, 128, 128,
MAX_SKL, MIN_AKL, MAX_AKL));
ALGORITHM_SUITE_TYPES.put("TripleDesSha256Rsa15", new AlgorithmSuiteType(
"TripleDesSha256Rsa15",
SPConstants.SHA256,
SPConstants.TRIPLE_DES,
SPConstants.KW_TRIPLE_DES,
SPConstants.KW_RSA15,
SPConstants.P_SHA1_L192,
SPConstants.P_SHA1_L192,
192, 192, 192,
MAX_SKL, MIN_AKL, MAX_AKL));
}
public static final class AlgorithmSuiteType {
private String name;
private String digest;
private String encryption;
private String symmetricKeyWrap;
private String asymmetricKeyWrap;
private String encryptionKeyDerivation;
private String signatureKeyDerivation;
private int encryptionDerivedKeyLength;
private int signatureDerivedKeyLength;
private int minimumSymmetricKeyLength;
private int maximumSymmetricKeyLength;
private int minimumAsymmetricKeyLength;
private int maximumAsymmetricKeyLength;
private String mgfAlgo;
private String ns;
private String encryptionDigest;
public AlgorithmSuiteType(String name, String digest, String encryption, String symmetricKeyWrap,
String asymmetricKeyWrap, String encryptionKeyDerivation,
String signatureKeyDerivation, int encryptionDerivedKeyLength,
int signatureDerivedKeyLength, int minimumSymmetricKeyLength,
int maximumSymmetricKeyLength, int minimumAsymmetricKeyLength,
int maximumAsymmetricKeyLength) {
this.name = name;
this.digest = digest;
this.encryption = encryption;
this.symmetricKeyWrap = symmetricKeyWrap;
this.asymmetricKeyWrap = asymmetricKeyWrap;
this.encryptionKeyDerivation = encryptionKeyDerivation;
this.signatureKeyDerivation = signatureKeyDerivation;
this.encryptionDerivedKeyLength = encryptionDerivedKeyLength;
this.signatureDerivedKeyLength = signatureDerivedKeyLength;
this.minimumSymmetricKeyLength = minimumSymmetricKeyLength;
this.maximumSymmetricKeyLength = maximumSymmetricKeyLength;
this.minimumAsymmetricKeyLength = minimumAsymmetricKeyLength;
this.maximumAsymmetricKeyLength = maximumAsymmetricKeyLength;
}
public AlgorithmSuiteType(AlgorithmSuiteType algorithmSuiteType) {
this.name = algorithmSuiteType.name;
this.digest = algorithmSuiteType.digest;
this.encryption = algorithmSuiteType.encryption;
this.symmetricKeyWrap = algorithmSuiteType.symmetricKeyWrap;
this.asymmetricKeyWrap = algorithmSuiteType.asymmetricKeyWrap;
this.encryptionKeyDerivation = algorithmSuiteType.encryptionKeyDerivation;
this.signatureKeyDerivation = algorithmSuiteType.signatureKeyDerivation;
this.encryptionDerivedKeyLength = algorithmSuiteType.encryptionDerivedKeyLength;
this.signatureDerivedKeyLength = algorithmSuiteType.signatureDerivedKeyLength;
this.minimumSymmetricKeyLength = algorithmSuiteType.minimumSymmetricKeyLength;
this.maximumSymmetricKeyLength = algorithmSuiteType.maximumSymmetricKeyLength;
this.minimumAsymmetricKeyLength = algorithmSuiteType.minimumAsymmetricKeyLength;
this.maximumAsymmetricKeyLength = algorithmSuiteType.maximumAsymmetricKeyLength;
this.mgfAlgo = algorithmSuiteType.mgfAlgo;
}
@Override
public boolean equals(Object object) {
if (object == this) {
return true;
}
if (!(object instanceof AlgorithmSuiteType)) {
return false;
}
AlgorithmSuiteType that = (AlgorithmSuiteType)object;
if (name != null && !name.equals(that.name)
|| name == null && that.name != null) {
return false;
}
if (digest != null && !digest.equals(that.digest)
|| digest == null && that.digest != null) {
return false;
}
if (encryption != null && !encryption.equals(that.encryption)
|| encryption == null && that.encryption != null) {
return false;
}
if (symmetricKeyWrap != null && !symmetricKeyWrap.equals(that.symmetricKeyWrap)
|| symmetricKeyWrap == null && that.symmetricKeyWrap != null) {
return false;
}
if (asymmetricKeyWrap != null && !asymmetricKeyWrap.equals(that.asymmetricKeyWrap)
|| asymmetricKeyWrap == null && that.asymmetricKeyWrap != null) {
return false;
}
if (encryptionKeyDerivation != null && !encryptionKeyDerivation.equals(that.encryptionKeyDerivation)
|| encryptionKeyDerivation == null && that.encryptionKeyDerivation != null) {
return false;
}
if (signatureKeyDerivation != null && !signatureKeyDerivation.equals(that.signatureKeyDerivation)
|| signatureKeyDerivation == null && that.signatureKeyDerivation != null) {
return false;
}
if (ns != null && !ns.equals(that.ns)
|| ns == null && that.ns != null) {
return false;
}
if (mgfAlgo != null && !mgfAlgo.equals(that.mgfAlgo)
|| mgfAlgo == null && that.mgfAlgo != null) {
return false;
}
if (encryptionDigest != null && !encryptionDigest.equals(that.encryptionDigest)
|| encryptionDigest == null && that.encryptionDigest != null) {
return false;
}
if (encryptionDerivedKeyLength != that.encryptionDerivedKeyLength
|| signatureDerivedKeyLength != that.signatureDerivedKeyLength
|| minimumSymmetricKeyLength != that.minimumSymmetricKeyLength
|| maximumSymmetricKeyLength != that.maximumSymmetricKeyLength
|| minimumAsymmetricKeyLength != that.minimumAsymmetricKeyLength
|| maximumAsymmetricKeyLength != that.maximumAsymmetricKeyLength) {
return false;
}
return true;
}
@Override
public int hashCode() {
int result = 17;
if (name != null) {
result = 31 * result + name.hashCode();
}
if (digest != null) {
result = 31 * result + digest.hashCode();
}
if (encryption != null) {
result = 31 * result + encryption.hashCode();
}
if (symmetricKeyWrap != null) {
result = 31 * result + symmetricKeyWrap.hashCode();
}
if (asymmetricKeyWrap != null) {
result = 31 * result + asymmetricKeyWrap.hashCode();
}
if (encryptionKeyDerivation != null) {
result = 31 * result + encryptionKeyDerivation.hashCode();
}
if (signatureKeyDerivation != null) {
result = 31 * result + signatureKeyDerivation.hashCode();
}
result = 31 * result + Integer.hashCode(encryptionDerivedKeyLength);
result = 31 * result + Integer.hashCode(signatureDerivedKeyLength);
result = 31 * result + Integer.hashCode(minimumSymmetricKeyLength);
result = 31 * result + Integer.hashCode(maximumSymmetricKeyLength);
result = 31 * result + Integer.hashCode(minimumAsymmetricKeyLength);
result = 31 * result + Integer.hashCode(maximumAsymmetricKeyLength);
if (mgfAlgo != null) {
result = 31 * result + mgfAlgo.hashCode();
}
if (ns != null) {
result = 31 * result + ns.hashCode();
}
if (encryptionDigest != null) {
result = 31 * result + encryptionDigest.hashCode();
}
return 31 * result + super.hashCode();
}
public String getName() {
return name;
}
public String getDigest() {
return digest;
}
public String getEncryption() {
return encryption;
}
public String getSymmetricKeyWrap() {
return symmetricKeyWrap;
}
public String getAsymmetricKeyWrap() {
return asymmetricKeyWrap;
}
public String getEncryptionKeyDerivation() {
return encryptionKeyDerivation;
}
public String getSignatureKeyDerivation() {
return signatureKeyDerivation;
}
public int getEncryptionDerivedKeyLength() {
return encryptionDerivedKeyLength;
}
public int getSignatureDerivedKeyLength() {
return signatureDerivedKeyLength;
}
public int getMinimumSymmetricKeyLength() {
return minimumSymmetricKeyLength;
}
public int getMaximumSymmetricKeyLength() {
return maximumSymmetricKeyLength;
}
public int getMinimumAsymmetricKeyLength() {
return minimumAsymmetricKeyLength;
}
public int getMaximumAsymmetricKeyLength() {
return maximumAsymmetricKeyLength;
}
public void setNamespace(String ns) {
this.ns = ns;
}
public String getNamespace() {
return ns;
}
public void setMGFAlgo(String mgfAlgo) {
this.mgfAlgo = mgfAlgo;
}
public String getMGFAlgo() {
return mgfAlgo;
}
public void setEncryptionDigest(String encryptionDigest) {
this.encryptionDigest = encryptionDigest;
}
public String getEncryptionDigest() {
return encryptionDigest;
}
}
public enum XPathType {
XPathNone(null),
XPath10(SPConstants.XPATH),
XPathFilter20(SPConstants.XPATH20),
AbsXPath(SPConstants.ABS_XPATH);
private static final Map LOOKUP = new HashMap<>();
static {
for (XPathType u : EnumSet.allOf(XPathType.class)) {
LOOKUP.put(u.name(), u);
}
}
public static XPathType lookUp(String name) {
return LOOKUP.get(name);
}
private String value;
public String getValue() {
return value;
}
XPathType(String value) {
this.value = value;
}
}
public enum C14NType {
ExclusiveC14N(SPConstants.EX_C14N),
InclusiveC14N(SPConstants.C14N),
InclusiveC14N11(SPConstants.C14N11);
private static final Map LOOKUP = new HashMap<>();
static {
for (C14NType u : EnumSet.allOf(C14NType.class)) {
LOOKUP.put(u.name(), u);
}
}
private String value;
public static C14NType lookUp(String name) {
return LOOKUP.get(name);
}
public String getValue() {
return value;
}
C14NType(String value) {
this.value = value;
}
}
public enum SOAPNormType {
SOAPNormalizationNone(null),
SOAPNormalization10(SPConstants.SOAP_NORMALIZATION_10);
private static final Map LOOKUP = new HashMap<>();
static {
for (SOAPNormType u : EnumSet.allOf(SOAPNormType.class)) {
LOOKUP.put(u.name(), u);
}
}
public static SOAPNormType lookUp(String name) {
return LOOKUP.get(name);
}
private String value;
public String getValue() {
return value;
}
SOAPNormType(String value) {
this.value = value;
}
}
public enum STRType {
STRTransformNone(null),
STRTransform10(SPConstants.STR_TRANSFORM_10);
private static final Map LOOKUP = new HashMap<>();
static {
for (STRType u : EnumSet.allOf(STRType.class)) {
LOOKUP.put(u.name(), u);
}
}
public static STRType lookUp(String name) {
return LOOKUP.get(name);
}
private String value;
public String getValue() {
return value;
}
STRType(String value) {
this.value = value;
}
}
private Policy nestedPolicy;
private AlgorithmSuiteType algorithmSuiteType;
private C14NType c14n = C14NType.ExclusiveC14N;
private SOAPNormType soapNormType = SOAPNormType.SOAPNormalizationNone;
private STRType strType = STRType.STRTransformNone;
private XPathType xPathType = XPathType.XPathNone;
private String symmetricSignature = SPConstants.HMAC_SHA1;
private String asymmetricSignature = SPConstants.RSA_SHA1;
private String computedKey = SPConstants.P_SHA1;
private String firstInvalidAlgorithmSuite;
public AlgorithmSuite(SPConstants.SPVersion version, Policy nestedPolicy) {
super(version);
this.nestedPolicy = nestedPolicy;
parseNestedPolicy(nestedPolicy, this);
}
@Override
public Policy getPolicy() {
return nestedPolicy;
}
@Override
public QName getName() {
return getVersion().getSPConstants().getAlgorithmSuite();
}
@Override
public boolean equals(Object object) {
if (object == this) {
return true;
}
if (!(object instanceof AlgorithmSuite)) {
return false;
}
AlgorithmSuite that = (AlgorithmSuite)object;
if (c14n != that.c14n || soapNormType != that.soapNormType || strType != that.strType
|| xPathType != that.xPathType) {
return false;
}
if (algorithmSuiteType != null && !algorithmSuiteType.equals(that.algorithmSuiteType)
|| algorithmSuiteType == null && that.algorithmSuiteType != null) {
return false;
}
if (symmetricSignature != null && !symmetricSignature.equals(that.symmetricSignature)
|| symmetricSignature == null && that.symmetricSignature != null) {
return false;
}
if (asymmetricSignature != null && !asymmetricSignature.equals(that.asymmetricSignature)
|| asymmetricSignature == null && that.asymmetricSignature != null) {
return false;
}
if (computedKey != null && !computedKey.equals(that.computedKey)
|| computedKey == null && that.computedKey != null) {
return false;
}
return super.equals(object);
}
@Override
public int hashCode() {
int result = 17;
if (c14n != null) {
result = 31 * result + c14n.hashCode();
}
if (soapNormType != null) {
result = 31 * result + soapNormType.hashCode();
}
if (strType != null) {
result = 31 * result + strType.hashCode();
}
if (xPathType != null) {
result = 31 * result + xPathType.hashCode();
}
if (algorithmSuiteType != null) {
result = 31 * result + algorithmSuiteType.hashCode();
}
if (symmetricSignature != null) {
result = 31 * result + symmetricSignature.hashCode();
}
if (asymmetricSignature != null) {
result = 31 * result + asymmetricSignature.hashCode();
}
if (computedKey != null) {
result = 31 * result + computedKey.hashCode();
}
return 31 * result + super.hashCode();
}
@Override
public PolicyComponent normalize() {
return super.normalize(getPolicy());
}
@Override
public void serialize(XMLStreamWriter writer) throws XMLStreamException {
super.serialize(writer, getPolicy());
}
@Override
protected AbstractSecurityAssertion cloneAssertion(Policy nestedPolicy) {
return new AlgorithmSuite(getVersion(), nestedPolicy);
}
protected void parseNestedPolicy(Policy nestedPolicy, AlgorithmSuite algorithmSuite) {
Iterator> alternatives = nestedPolicy.getAlternatives();
//we just process the first alternative
//this means that if we have a compact policy only the first alternative is visible
//in contrary to a normalized policy where just one alternative exists
if (alternatives.hasNext()) {
List assertions = alternatives.next();
for (Assertion assertion : assertions) {
String assertionName = assertion.getName().getLocalPart();
String assertionNamespace = assertion.getName().getNamespaceURI();
if (!getVersion().getNamespace().equals(assertionNamespace)) {
parseCustomAssertion(assertion);
continue;
}
AlgorithmSuiteType algorithmSuiteType = ALGORITHM_SUITE_TYPES.get(assertionName);
if (algorithmSuiteType != null) {
if (algorithmSuite.getAlgorithmSuiteType() != null) {
throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
}
// Clone so as not to change the namespace for other AlgorithmSuiteTypes...
AlgorithmSuiteType newAlgorithmSuiteType = new AlgorithmSuiteType(algorithmSuiteType);
newAlgorithmSuiteType.setNamespace(getVersion().getNamespace());
algorithmSuite.setAlgorithmSuiteType(newAlgorithmSuiteType);
continue;
} else {
firstInvalidAlgorithmSuite = assertionName;
}
C14NType c14NType = C14NType.lookUp(assertionName);
if (c14NType != null) {
algorithmSuite.setC14n(c14NType);
continue;
}
SOAPNormType soapNormType = SOAPNormType.lookUp(assertionName);
if (soapNormType != null) {
if (algorithmSuite.getSoapNormType() == SOAPNormType.SOAPNormalization10) {
throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
}
algorithmSuite.setSoapNormType(soapNormType);
continue;
}
STRType strType = STRType.lookUp(assertionName);
if (strType != null) {
if (algorithmSuite.getStrType() == STRType.STRTransform10) {
throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
}
algorithmSuite.setStrType(strType);
continue;
}
XPathType xPathType = XPathType.lookUp(assertionName);
if (xPathType != null) {
if (algorithmSuite.getXPathType() != XPathType.XPathNone) {
throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
}
algorithmSuite.setXPathType(xPathType);
continue;
}
}
}
}
protected void parseCustomAssertion(Assertion assertion) {
}
public AlgorithmSuiteType getAlgorithmSuiteType() {
return algorithmSuiteType;
}
protected void setAlgorithmSuiteType(AlgorithmSuiteType algorithmSuiteType) {
this.algorithmSuiteType = algorithmSuiteType;
}
public C14NType getC14n() {
return c14n;
}
protected void setC14n(C14NType c14n) {
this.c14n = c14n;
}
public SOAPNormType getSoapNormType() {
return soapNormType;
}
protected void setSoapNormType(SOAPNormType soapNormType) {
this.soapNormType = soapNormType;
}
public STRType getStrType() {
return strType;
}
protected void setStrType(STRType strType) {
this.strType = strType;
}
public XPathType getXPathType() {
return xPathType;
}
protected void setXPathType(XPathType xPathType) {
this.xPathType = xPathType;
}
public String getAsymmetricSignature() {
return asymmetricSignature;
}
public String getSymmetricSignature() {
return symmetricSignature;
}
public String getComputedKey() {
return computedKey;
}
public static Collection getSupportedAlgorithmSuiteNames() {
return ALGORITHM_SUITE_TYPES.keySet();
}
public void setSymmetricSignature(String symmetricSignature) {
this.symmetricSignature = symmetricSignature;
}
public void setAsymmetricSignature(String asymmetricSignature) {
this.asymmetricSignature = asymmetricSignature;
}
public String getFirstInvalidAlgorithmSuite() {
return firstInvalidAlgorithmSuite;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy