View Javadoc
1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements. See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership. The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License. You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied. See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  
20  package org.apache.wss4j.dom.message;
21  
22  import java.util.ArrayList;
23  import java.util.Collections;
24  import java.util.List;
25  
26  import javax.crypto.KeyGenerator;
27  import javax.crypto.SecretKey;
28  import javax.security.auth.callback.CallbackHandler;
29  
30  import org.apache.wss4j.common.util.SOAPUtil;
31  import org.w3c.dom.Document;
32  import org.apache.wss4j.common.crypto.Crypto;
33  import org.apache.wss4j.common.crypto.CryptoFactory;
34  import org.apache.wss4j.common.derivedKey.ConversationConstants;
35  import org.apache.wss4j.common.util.XMLUtils;
36  import org.apache.wss4j.dom.WSConstants;
37  import org.apache.wss4j.dom.common.CustomHandler;
38  import org.apache.wss4j.dom.common.KeystoreCallbackHandler;
39  import org.apache.wss4j.dom.common.SecretKeyCallbackHandler;
40  
41  import org.apache.wss4j.dom.engine.WSSConfig;
42  import org.apache.wss4j.dom.engine.WSSecurityEngine;
43  import org.apache.wss4j.dom.handler.HandlerAction;
44  import org.apache.wss4j.dom.handler.RequestData;
45  import org.apache.wss4j.dom.handler.WSHandlerConstants;
46  import org.apache.wss4j.dom.handler.WSHandlerResult;
47  
48  import org.junit.jupiter.api.Test;
49  
50  import static org.junit.jupiter.api.Assertions.assertFalse;
51  import static org.junit.jupiter.api.Assertions.assertTrue;
52  
53  /**
54   * A set of tests for using a derived key for encryption/signature using WSHandler actions.
55   */
56  public class DerivedKeyActionTest {
57      private static final org.slf4j.Logger LOG =
58          org.slf4j.LoggerFactory.getLogger(DerivedKeyActionTest.class);
59      private CallbackHandler callbackHandler = new KeystoreCallbackHandler();
60      private Crypto crypto;
61  
62      public DerivedKeyActionTest() throws Exception {
63          crypto = CryptoFactory.getInstance("wss40.properties");
64          WSSConfig.init();
65      }
66  
67      @Test
68      public void testSignatureThumbprintSHA1() throws Exception {
69          final WSSConfig cfg = WSSConfig.getNewInstance();
70          final RequestData reqData = new RequestData();
71          reqData.setWssConfig(cfg);
72          reqData.setUsername("wss40");
73  
74          java.util.Map<String, Object> config = new java.util.TreeMap<>();
75          config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
76          config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
77          config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
78          reqData.setMsgContext(config);
79  
80          final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
81          CustomHandler handler = new CustomHandler();
82          HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
83          handler.send(
84              doc,
85              reqData,
86              Collections.singletonList(action),
87              true
88          );
89          String outputString =
90              XMLUtils.prettyDocumentToString(doc);
91          assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
92          if (LOG.isDebugEnabled()) {
93              LOG.debug(outputString);
94          }
95  
96          verify(doc);
97      }
98  
99      @Test
100     public void testSignatureThumbprintSHA1OldNamespace() throws Exception {
101         final WSSConfig cfg = WSSConfig.getNewInstance();
102         final RequestData reqData = new RequestData();
103         reqData.setWssConfig(cfg);
104         reqData.setUsername("wss40");
105 
106         java.util.Map<String, Object> config = new java.util.TreeMap<>();
107         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
108         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
109         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
110         config.put(WSHandlerConstants.USE_2005_12_NAMESPACE, "false");
111         reqData.setMsgContext(config);
112 
113         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
114         CustomHandler handler = new CustomHandler();
115         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
116         handler.send(
117             doc,
118             reqData,
119             Collections.singletonList(action),
120             true
121         );
122         String outputString =
123             XMLUtils.prettyDocumentToString(doc);
124         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_02));
125         if (LOG.isDebugEnabled()) {
126             LOG.debug(outputString);
127         }
128 
129         verify(doc);
130     }
131 
132     @Test
133     public void testSignatureThumbprintSHA1StrongDigest() throws Exception {
134         final WSSConfig cfg = WSSConfig.getNewInstance();
135         final RequestData reqData = new RequestData();
136         reqData.setWssConfig(cfg);
137         reqData.setUsername("wss40");
138 
139         java.util.Map<String, Object> config = new java.util.TreeMap<>();
140         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
141         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
142         config.put(WSHandlerConstants.SIG_DIGEST_ALGO, WSConstants.SHA256);
143         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
144         reqData.setMsgContext(config);
145 
146         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
147         CustomHandler handler = new CustomHandler();
148         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
149         handler.send(
150             doc,
151             reqData,
152             Collections.singletonList(action),
153             true
154         );
155         String outputString =
156             XMLUtils.prettyDocumentToString(doc);
157         if (LOG.isDebugEnabled()) {
158             LOG.debug(outputString);
159         }
160 
161         verify(doc);
162     }
163 
164     @Test
165     public void testSignatureThumbprintDifferentKeyLength() throws Exception {
166         final WSSConfig cfg = WSSConfig.getNewInstance();
167         final RequestData reqData = new RequestData();
168         reqData.setWssConfig(cfg);
169         reqData.setUsername("wss40");
170 
171         java.util.Map<String, Object> config = new java.util.TreeMap<>();
172         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
173         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
174         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
175         config.put(WSHandlerConstants.DERIVED_SIGNATURE_KEY_LENGTH, "16");
176         reqData.setMsgContext(config);
177 
178         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
179         CustomHandler handler = new CustomHandler();
180         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
181         handler.send(
182             doc,
183             reqData,
184             Collections.singletonList(action),
185             true
186         );
187         String outputString =
188             XMLUtils.prettyDocumentToString(doc);
189         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
190         if (LOG.isDebugEnabled()) {
191             LOG.debug(outputString);
192         }
193 
194         verify(doc);
195     }
196 
197     @Test
198     public void testSignatureSKI() throws Exception {
199         final WSSConfig cfg = WSSConfig.getNewInstance();
200         final RequestData reqData = new RequestData();
201         reqData.setWssConfig(cfg);
202         reqData.setUsername("wss40");
203 
204         java.util.Map<String, Object> config = new java.util.TreeMap<>();
205         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
206         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
207         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "SKIKeyIdentifier");
208         reqData.setMsgContext(config);
209 
210         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
211         CustomHandler handler = new CustomHandler();
212         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
213         handler.send(
214             doc,
215             reqData,
216             Collections.singletonList(action),
217             true
218         );
219         String outputString =
220             XMLUtils.prettyDocumentToString(doc);
221         if (LOG.isDebugEnabled()) {
222             LOG.debug(outputString);
223         }
224 
225         verify(doc);
226     }
227 
228     @Test
229     public void testSignatureX509() throws Exception {
230         final WSSConfig cfg = WSSConfig.getNewInstance();
231         final RequestData reqData = new RequestData();
232         reqData.setWssConfig(cfg);
233         reqData.setUsername("wss40");
234 
235         java.util.Map<String, Object> config = new java.util.TreeMap<>();
236         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
237         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
238         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "DirectReference");
239         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "X509KeyIdentifier");
240         reqData.setMsgContext(config);
241 
242         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
243         CustomHandler handler = new CustomHandler();
244         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
245         handler.send(
246             doc,
247             reqData,
248             Collections.singletonList(action),
249             true
250         );
251         String outputString =
252             XMLUtils.prettyDocumentToString(doc);
253         if (LOG.isDebugEnabled()) {
254             LOG.debug(outputString);
255         }
256 
257         verify(doc);
258     }
259 
260     @Test
261     public void testSignatureEncryptedKeyThumbprintSHA1() throws Exception {
262         final WSSConfig cfg = WSSConfig.getNewInstance();
263         final RequestData reqData = new RequestData();
264         reqData.setWssConfig(cfg);
265         reqData.setUsername("wss40");
266 
267         java.util.Map<String, Object> config = new java.util.TreeMap<>();
268         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
269         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
270         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "EncryptedKey");
271         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
272         reqData.setMsgContext(config);
273 
274         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
275         CustomHandler handler = new CustomHandler();
276         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
277         handler.send(
278             doc,
279             reqData,
280             Collections.singletonList(action),
281             true
282         );
283         String outputString =
284             XMLUtils.prettyDocumentToString(doc);
285         if (LOG.isDebugEnabled()) {
286             LOG.debug(outputString);
287         }
288 
289         verify(doc);
290     }
291 
292     @Test
293     public void testSignatureSCT() throws Exception {
294         final WSSConfig cfg = WSSConfig.getNewInstance();
295         final RequestData reqData = new RequestData();
296         reqData.setWssConfig(cfg);
297 
298         // Generate a Key
299         SecretKeyCallbackHandler secretKeyCallbackHandler = new SecretKeyCallbackHandler();
300         KeyGenerator keyGen = KeyGenerator.getInstance("AES");
301         keyGen.init(128);
302         SecretKey key = keyGen.generateKey();
303         byte[] keyData = key.getEncoded();
304         secretKeyCallbackHandler.setOutboundSecret(keyData);
305 
306         java.util.Map<String, Object> config = new java.util.TreeMap<>();
307         config.put(WSHandlerConstants.PW_CALLBACK_REF, secretKeyCallbackHandler);
308         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "SecurityContextToken");
309         reqData.setMsgContext(config);
310 
311         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
312         CustomHandler handler = new CustomHandler();
313         HandlerAction action = new HandlerAction(WSConstants.DKT_SIGN);
314         handler.send(
315             doc,
316             reqData,
317             Collections.singletonList(action),
318             true
319         );
320         String outputString =
321             XMLUtils.prettyDocumentToString(doc);
322         if (LOG.isDebugEnabled()) {
323             LOG.debug(outputString);
324         }
325 
326         verify(doc, secretKeyCallbackHandler);
327     }
328 
329     @Test
330     public void testEncryptionThumbprintSHA1() throws Exception {
331         final WSSConfig cfg = WSSConfig.getNewInstance();
332         final RequestData reqData = new RequestData();
333         reqData.setWssConfig(cfg);
334         reqData.setUsername("wss40");
335 
336         java.util.Map<String, Object> config = new java.util.TreeMap<>();
337         config.put(WSHandlerConstants.ENC_PROP_FILE, "wss40.properties");
338         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
339         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "EncryptedKey");
340         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
341         reqData.setMsgContext(config);
342 
343         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
344         CustomHandler handler = new CustomHandler();
345         HandlerAction action = new HandlerAction(WSConstants.DKT_ENCR);
346         handler.send(
347             doc,
348             reqData,
349             Collections.singletonList(action),
350             true
351         );
352         String outputString =
353             XMLUtils.prettyDocumentToString(doc);
354         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
355         if (LOG.isDebugEnabled()) {
356             LOG.debug(outputString);
357         }
358 
359         verify(doc);
360     }
361 
362     @Test
363     public void testEncryptionThumbprintAES256() throws Exception {
364         final WSSConfig cfg = WSSConfig.getNewInstance();
365         final RequestData reqData = new RequestData();
366         reqData.setWssConfig(cfg);
367         reqData.setUsername("wss40");
368 
369         java.util.Map<String, Object> config = new java.util.TreeMap<>();
370         config.put(WSHandlerConstants.ENC_PROP_FILE, "wss40.properties");
371         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
372         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "EncryptedKey");
373         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
374         config.put(WSHandlerConstants.ENC_SYM_ALGO, WSConstants.AES_256);
375         reqData.setMsgContext(config);
376 
377         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
378         CustomHandler handler = new CustomHandler();
379         HandlerAction action = new HandlerAction(WSConstants.DKT_ENCR);
380         handler.send(
381             doc,
382             reqData,
383             Collections.singletonList(action),
384             true
385         );
386         String outputString =
387             XMLUtils.prettyDocumentToString(doc);
388         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
389         assertTrue(outputString.contains(WSConstants.AES_256));
390         assertFalse(outputString.contains(WSConstants.AES_128));
391         if (LOG.isDebugEnabled()) {
392             LOG.debug(outputString);
393         }
394 
395         verify(doc);
396     }
397 
398     @Test
399     public void testEncryptionSCT() throws Exception {
400         final WSSConfig cfg = WSSConfig.getNewInstance();
401         final RequestData reqData = new RequestData();
402         reqData.setWssConfig(cfg);
403         reqData.setUsername("wss40");
404 
405         // Generate a Key
406         SecretKeyCallbackHandler secretKeyCallbackHandler = new SecretKeyCallbackHandler();
407         KeyGenerator keyGen = KeyGenerator.getInstance("AES");
408         keyGen.init(128);
409         SecretKey key = keyGen.generateKey();
410         byte[] keyData = key.getEncoded();
411         secretKeyCallbackHandler.setOutboundSecret(keyData);
412 
413         java.util.Map<String, Object> config = new java.util.TreeMap<>();
414         config.put(WSHandlerConstants.PW_CALLBACK_REF, secretKeyCallbackHandler);
415         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "SecurityContextToken");
416         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
417         reqData.setMsgContext(config);
418 
419         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
420         CustomHandler handler = new CustomHandler();
421         HandlerAction action = new HandlerAction(WSConstants.DKT_ENCR);
422         handler.send(
423             doc,
424             reqData,
425             Collections.singletonList(action),
426             true
427         );
428         String outputString =
429             XMLUtils.prettyDocumentToString(doc);
430         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
431         if (LOG.isDebugEnabled()) {
432             LOG.debug(outputString);
433         }
434 
435         verify(doc, secretKeyCallbackHandler);
436     }
437 
438     @Test
439     public void testSignatureEncryptionThumbprintSHA1() throws Exception {
440         final WSSConfig cfg = WSSConfig.getNewInstance();
441         final RequestData reqData = new RequestData();
442         reqData.setWssConfig(cfg);
443         reqData.setUsername("wss40");
444 
445         java.util.Map<String, Object> config = new java.util.TreeMap<>();
446         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
447         config.put(WSHandlerConstants.ENC_PROP_FILE, "wss40.properties");
448         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
449         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "EncryptedKey");
450         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
451         reqData.setMsgContext(config);
452 
453         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
454         CustomHandler handler = new CustomHandler();
455         List<HandlerAction> actions = new ArrayList<>();
456         actions.add(new HandlerAction(WSConstants.DKT_SIGN));
457         actions.add(new HandlerAction(WSConstants.DKT_ENCR));
458         handler.send(
459             doc,
460             reqData,
461             actions,
462             true
463         );
464         String outputString =
465             XMLUtils.prettyDocumentToString(doc);
466         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
467         if (LOG.isDebugEnabled()) {
468             LOG.debug(outputString);
469         }
470 
471         verify(doc);
472     }
473 
474     @Test
475     public void testEncryptionSignatureThumbprintSHA1() throws Exception {
476         final WSSConfig cfg = WSSConfig.getNewInstance();
477         final RequestData reqData = new RequestData();
478         reqData.setWssConfig(cfg);
479         reqData.setUsername("wss40");
480 
481         java.util.Map<String, Object> config = new java.util.TreeMap<>();
482         config.put(WSHandlerConstants.SIG_PROP_FILE, "wss40.properties");
483         config.put(WSHandlerConstants.ENC_PROP_FILE, "wss40.properties");
484         config.put(WSHandlerConstants.PW_CALLBACK_REF, callbackHandler);
485         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "EncryptedKey");
486         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
487         reqData.setMsgContext(config);
488 
489         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
490         CustomHandler handler = new CustomHandler();
491         List<HandlerAction> actions = new ArrayList<>();
492         actions.add(new HandlerAction(WSConstants.DKT_ENCR));
493         actions.add(new HandlerAction(WSConstants.DKT_SIGN));
494         handler.send(
495             doc,
496             reqData,
497             actions,
498             true
499         );
500         String outputString =
501             XMLUtils.prettyDocumentToString(doc);
502         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
503         if (LOG.isDebugEnabled()) {
504             LOG.debug(outputString);
505         }
506 
507         verify(doc);
508     }
509 
510     @Test
511     public void testSignatureEncryptionSecurityContextToken() throws Exception {
512         final WSSConfig cfg = WSSConfig.getNewInstance();
513         final RequestData reqData = new RequestData();
514         reqData.setWssConfig(cfg);
515         reqData.setUsername("wss40");
516 
517         // Generate a Key
518         SecretKeyCallbackHandler secretKeyCallbackHandler = new SecretKeyCallbackHandler();
519         KeyGenerator keyGen = KeyGenerator.getInstance("AES");
520         keyGen.init(128);
521         SecretKey key = keyGen.generateKey();
522         byte[] keyData = key.getEncoded();
523         secretKeyCallbackHandler.setOutboundSecret(keyData);
524 
525         java.util.Map<String, Object> config = new java.util.TreeMap<>();
526         config.put(WSHandlerConstants.PW_CALLBACK_REF, secretKeyCallbackHandler);
527         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "SecurityContextToken");
528         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
529         reqData.setMsgContext(config);
530 
531         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
532         CustomHandler handler = new CustomHandler();
533         List<HandlerAction> actions = new ArrayList<>();
534         actions.add(new HandlerAction(WSConstants.DKT_SIGN));
535         actions.add(new HandlerAction(WSConstants.DKT_ENCR));
536         handler.send(
537             doc,
538             reqData,
539             actions,
540             true
541         );
542         String outputString =
543             XMLUtils.prettyDocumentToString(doc);
544         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
545         if (LOG.isDebugEnabled()) {
546             LOG.debug(outputString);
547         }
548 
549         verify(doc, secretKeyCallbackHandler);
550     }
551 
552     @Test
553     public void testEncryptionSignatureSecurityContextToken() throws Exception {
554         final WSSConfig cfg = WSSConfig.getNewInstance();
555         final RequestData reqData = new RequestData();
556         reqData.setWssConfig(cfg);
557         reqData.setUsername("wss40");
558 
559         // Generate a Key
560         SecretKeyCallbackHandler secretKeyCallbackHandler = new SecretKeyCallbackHandler();
561         KeyGenerator keyGen = KeyGenerator.getInstance("AES");
562         keyGen.init(128);
563         SecretKey key = keyGen.generateKey();
564         byte[] keyData = key.getEncoded();
565         secretKeyCallbackHandler.setOutboundSecret(keyData);
566 
567         java.util.Map<String, Object> config = new java.util.TreeMap<>();
568         config.put(WSHandlerConstants.PW_CALLBACK_REF, secretKeyCallbackHandler);
569         config.put(WSHandlerConstants.DERIVED_TOKEN_REFERENCE, "SecurityContextToken");
570         config.put(WSHandlerConstants.DERIVED_TOKEN_KEY_ID, "Thumbprint");
571         reqData.setMsgContext(config);
572 
573         final Document doc = SOAPUtil.toSOAPPart(SOAPUtil.SAMPLE_SOAP_MSG);
574         CustomHandler handler = new CustomHandler();
575         List<HandlerAction> actions = new ArrayList<>();
576         actions.add(new HandlerAction(WSConstants.DKT_ENCR));
577         actions.add(new HandlerAction(WSConstants.DKT_SIGN));
578         handler.send(
579             doc,
580             reqData,
581             actions,
582             true
583         );
584         String outputString =
585             XMLUtils.prettyDocumentToString(doc);
586         assertTrue(outputString.contains(ConversationConstants.WSC_NS_05_12));
587         if (LOG.isDebugEnabled()) {
588             LOG.debug(outputString);
589         }
590 
591         verify(doc, secretKeyCallbackHandler);
592     }
593 
594     private WSHandlerResult verify(Document doc) throws Exception {
595         return verify(doc, callbackHandler);
596     }
597 
598     private WSHandlerResult verify(Document doc, CallbackHandler cbHandler) throws Exception {
599         WSSecurityEngine secEngine = new WSSecurityEngine();
600         WSHandlerResult results =
601             secEngine.processSecurityHeader(doc, null, cbHandler, crypto);
602         String outputString =
603             XMLUtils.prettyDocumentToString(doc);
604         assertTrue(outputString.indexOf("counter_port_type") > 0 ? true : false);
605 
606         return results;
607     }
608 
609 }