1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.wss4j.policy.model;
20
21 import org.apache.neethi.Assertion;
22 import org.apache.neethi.Policy;
23 import org.apache.wss4j.policy.SPConstants;
24
25 import javax.xml.namespace.QName;
26 import java.util.Iterator;
27 import java.util.List;
28
29 public class AsymmetricBinding extends AbstractSymmetricAsymmetricBinding {
30
31 private InitiatorToken initiatorToken;
32 private InitiatorSignatureToken initiatorSignatureToken;
33 private InitiatorEncryptionToken initiatorEncryptionToken;
34 private RecipientToken recipientToken;
35 private RecipientSignatureToken recipientSignatureToken;
36 private RecipientEncryptionToken recipientEncryptionToken;
37
38 public AsymmetricBinding(SPConstants.SPVersion version, Policy nestedPolicy) {
39 super(version, nestedPolicy);
40
41 parseNestedPolicy(nestedPolicy, this);
42 }
43
44 @Override
45 public QName getName() {
46 return getVersion().getSPConstants().getAsymmetricBinding();
47 }
48
49 @Override
50 public boolean equals(Object object) {
51 if (object == this) {
52 return true;
53 }
54
55 if (!(object instanceof AsymmetricBinding)) {
56 return false;
57 }
58
59 AsymmetricBinding that = (AsymmetricBinding)object;
60 if (initiatorToken != null && !initiatorToken.equals(that.initiatorToken)
61 || initiatorToken == null && that.initiatorToken != null) {
62 return false;
63 }
64 if (initiatorSignatureToken != null && !initiatorSignatureToken.equals(that.initiatorSignatureToken)
65 || initiatorSignatureToken == null && that.initiatorSignatureToken != null) {
66 return false;
67 }
68 if (initiatorEncryptionToken != null && !initiatorEncryptionToken.equals(that.initiatorEncryptionToken)
69 || initiatorEncryptionToken == null && that.initiatorEncryptionToken != null) {
70 return false;
71 }
72
73 if (recipientToken != null && !recipientToken.equals(that.recipientToken)
74 || recipientToken == null && that.recipientToken != null) {
75 return false;
76 }
77 if (recipientSignatureToken != null && !recipientSignatureToken.equals(that.recipientSignatureToken)
78 || recipientSignatureToken == null && that.recipientSignatureToken != null) {
79 return false;
80 }
81 if (recipientEncryptionToken != null && !recipientEncryptionToken.equals(that.recipientEncryptionToken)
82 || recipientEncryptionToken == null && that.recipientEncryptionToken != null) {
83 return false;
84 }
85
86 return super.equals(object);
87 }
88
89 @Override
90 public int hashCode() {
91 int result = 17;
92 if (initiatorToken != null) {
93 result = 31 * result + initiatorToken.hashCode();
94 }
95 if (initiatorSignatureToken != null) {
96 result = 31 * result + initiatorSignatureToken.hashCode();
97 }
98 if (initiatorEncryptionToken != null) {
99 result = 31 * result + initiatorEncryptionToken.hashCode();
100 }
101
102 if (recipientToken != null) {
103 result = 31 * result + recipientToken.hashCode();
104 }
105 if (recipientSignatureToken != null) {
106 result = 31 * result + recipientSignatureToken.hashCode();
107 }
108 if (recipientEncryptionToken != null) {
109 result = 31 * result + recipientEncryptionToken.hashCode();
110 }
111
112 return 31 * result + super.hashCode();
113 }
114
115 @Override
116 protected AbstractSecurityAssertion cloneAssertion(Policy nestedPolicy) {
117 return new AsymmetricBinding(getVersion(), nestedPolicy);
118 }
119
120 protected void parseNestedPolicy(Policy nestedPolicy, AsymmetricBinding asymmetricBinding) {
121 Iterator<List<Assertion>> alternatives = nestedPolicy.getAlternatives();
122
123
124
125 if (alternatives.hasNext()) {
126 List<Assertion> assertions = alternatives.next();
127 for (Assertion assertion : assertions) {
128 String assertionName = assertion.getName().getLocalPart();
129 String assertionNamespace = assertion.getName().getNamespaceURI();
130
131 QName initiatorToken = getVersion().getSPConstants().getInitiatorToken();
132 if (initiatorToken.getLocalPart().equals(assertionName)
133 && initiatorToken.getNamespaceURI().equals(assertionNamespace)) {
134 if (asymmetricBinding.getInitiatorToken() != null
135 || asymmetricBinding.getInitiatorSignatureToken() != null
136 || asymmetricBinding.getInitiatorEncryptionToken() != null) {
137 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
138 }
139 final InitiatorToken initiatorToken1 = (InitiatorToken) assertion;
140 asymmetricBinding.setInitiatorToken(initiatorToken1);
141 initiatorToken1.setParentAssertion(asymmetricBinding);
142 continue;
143 }
144
145 QName initiatorSigToken = getVersion().getSPConstants().getInitiatorSignatureToken();
146 if (initiatorSigToken.getLocalPart().equals(assertionName)
147 && initiatorSigToken.getNamespaceURI().equals(assertionNamespace)) {
148 if (asymmetricBinding.getInitiatorToken() != null
149 || asymmetricBinding.getInitiatorSignatureToken() != null) {
150 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
151 }
152 final InitiatorSignatureToken initiatorSignatureToken1 = (InitiatorSignatureToken) assertion;
153 asymmetricBinding.setInitiatorSignatureToken(initiatorSignatureToken1);
154 initiatorSignatureToken1.setParentAssertion(asymmetricBinding);
155 continue;
156 }
157
158 QName initiatorEncToken = getVersion().getSPConstants().getInitiatorEncryptionToken();
159 if (initiatorEncToken.getLocalPart().equals(assertionName)
160 && initiatorEncToken.getNamespaceURI().equals(assertionNamespace)) {
161 if (asymmetricBinding.getInitiatorToken() != null
162 || asymmetricBinding.getInitiatorEncryptionToken() != null) {
163 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
164 }
165 final InitiatorEncryptionToken initiatorEncryptionToken1 = (InitiatorEncryptionToken) assertion;
166 asymmetricBinding.setInitiatorEncryptionToken(initiatorEncryptionToken1);
167 initiatorEncryptionToken1.setParentAssertion(asymmetricBinding);
168 continue;
169 }
170
171 QName recipientToken = getVersion().getSPConstants().getRecipientToken();
172 if (recipientToken.getLocalPart().equals(assertionName)
173 && recipientToken.getNamespaceURI().equals(assertionNamespace)) {
174 if (asymmetricBinding.getRecipientToken() != null
175 || asymmetricBinding.getRecipientSignatureToken() != null
176 || asymmetricBinding.getRecipientEncryptionToken() != null) {
177 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
178 }
179 final RecipientToken recipientToken1 = (RecipientToken) assertion;
180 asymmetricBinding.setRecipientToken(recipientToken1);
181 recipientToken1.setParentAssertion(asymmetricBinding);
182 continue;
183 }
184
185 QName recipientSigToken = getVersion().getSPConstants().getRecipientSignatureToken();
186 if (recipientSigToken.getLocalPart().equals(assertionName)
187 && recipientSigToken.getNamespaceURI().equals(assertionNamespace)) {
188 if (asymmetricBinding.getRecipientToken() != null
189 || asymmetricBinding.getRecipientSignatureToken() != null) {
190 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
191 }
192 final RecipientSignatureToken recipientSignatureToken1 = (RecipientSignatureToken) assertion;
193 asymmetricBinding.setRecipientSignatureToken(recipientSignatureToken1);
194 recipientSignatureToken1.setParentAssertion(asymmetricBinding);
195 continue;
196 }
197
198 QName recipientEncToken = getVersion().getSPConstants().getRecipientEncryptionToken();
199 if (recipientEncToken.getLocalPart().equals(assertionName)
200 && recipientEncToken.getNamespaceURI().equals(assertionNamespace)) {
201 if (asymmetricBinding.getRecipientToken() != null
202 || asymmetricBinding.getRecipientEncryptionToken() != null) {
203 throw new IllegalArgumentException(SPConstants.ERR_INVALID_POLICY);
204 }
205 final RecipientEncryptionToken recipientEncryptionToken1 = (RecipientEncryptionToken) assertion;
206 asymmetricBinding.setRecipientEncryptionToken(recipientEncryptionToken1);
207 recipientEncryptionToken1.setParentAssertion(asymmetricBinding);
208 continue;
209 }
210 }
211 }
212 }
213
214 public InitiatorToken getInitiatorToken() {
215 return initiatorToken;
216 }
217
218 protected void setInitiatorToken(InitiatorToken initiatorToken) {
219 this.initiatorToken = initiatorToken;
220 }
221
222 public InitiatorSignatureToken getInitiatorSignatureToken() {
223 return initiatorSignatureToken;
224 }
225
226 protected void setInitiatorSignatureToken(InitiatorSignatureToken initiatorSignatureToken) {
227 this.initiatorSignatureToken = initiatorSignatureToken;
228 }
229
230 public InitiatorEncryptionToken getInitiatorEncryptionToken() {
231 return initiatorEncryptionToken;
232 }
233
234 protected void setInitiatorEncryptionToken(InitiatorEncryptionToken initiatorEncryptionToken) {
235 this.initiatorEncryptionToken = initiatorEncryptionToken;
236 }
237
238 public RecipientToken getRecipientToken() {
239 return recipientToken;
240 }
241
242 protected void setRecipientToken(RecipientToken recipientToken) {
243 this.recipientToken = recipientToken;
244 }
245
246 public RecipientSignatureToken getRecipientSignatureToken() {
247 return recipientSignatureToken;
248 }
249
250 protected void setRecipientSignatureToken(RecipientSignatureToken recipientSignatureToken) {
251 this.recipientSignatureToken = recipientSignatureToken;
252 }
253
254 public RecipientEncryptionToken getRecipientEncryptionToken() {
255 return recipientEncryptionToken;
256 }
257
258 protected void setRecipientEncryptionToken(RecipientEncryptionToken recipientEncryptionToken) {
259 this.recipientEncryptionToken = recipientEncryptionToken;
260 }
261 }