View Javadoc

1   /*
2    * Copyright 2006 the original author or authors.
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.springframework.ws.soap.security.xwss.callback;
18  
19  import java.io.IOException;
20  import java.security.cert.X509Certificate;
21  import javax.security.auth.callback.Callback;
22  import javax.security.auth.callback.CallbackHandler;
23  import javax.security.auth.callback.UnsupportedCallbackException;
24  
25  import com.sun.xml.wss.impl.callback.CertificateValidationCallback;
26  import com.sun.xml.wss.impl.callback.PasswordValidationCallback;
27  import com.sun.xml.wss.impl.callback.TimestampValidationCallback;
28  
29  import org.springframework.ws.soap.security.callback.CallbackHandlerChain;
30  
31  /**
32   * Represents a chain of <code>CallbackHandler</code>s. For each callback, each of the handlers is called in term. If a
33   * handler throws a <code>UnsupportedCallbackException</code>, the next handler is tried.
34   *
35   * @author Arjen Poutsma
36   * @since 1.0.0
37   */
38  public class XwssCallbackHandlerChain extends CallbackHandlerChain {
39  
40      public XwssCallbackHandlerChain(CallbackHandler[] callbackHandlers) {
41          super(callbackHandlers);
42      }
43  
44      protected void handleInternal(Callback callback) throws IOException, UnsupportedCallbackException {
45          if (callback instanceof CertificateValidationCallback) {
46              handleCertificateValidationCallback((CertificateValidationCallback) callback);
47          }
48          else if (callback instanceof PasswordValidationCallback) {
49              handlePasswordValidationCallback((PasswordValidationCallback) callback);
50          }
51          else if (callback instanceof TimestampValidationCallback) {
52              handleTimestampValidationCallback((TimestampValidationCallback) callback);
53          }
54          else {
55              super.handleInternal(callback);
56          }
57      }
58  
59      private void handleCertificateValidationCallback(CertificateValidationCallback callback) {
60          callback.setValidator(new CertificateValidatorChain(callback));
61      }
62  
63      private void handlePasswordValidationCallback(PasswordValidationCallback callback) {
64          callback.setValidator(new PasswordValidatorChain(callback));
65      }
66  
67      private void handleTimestampValidationCallback(TimestampValidationCallback callback) {
68          callback.setValidator(new TimestampValidatorChain(callback));
69      }
70  
71      private class TimestampValidatorChain implements TimestampValidationCallback.TimestampValidator {
72  
73          private TimestampValidationCallback callback;
74  
75          private TimestampValidatorChain(TimestampValidationCallback callback) {
76              this.callback = callback;
77          }
78  
79          public void validate(TimestampValidationCallback.Request request)
80                  throws TimestampValidationCallback.TimestampValidationException {
81              for (int i = 0; i < getCallbackHandlers().length; i++) {
82                  CallbackHandler callbackHandler = getCallbackHandlers()[i];
83                  try {
84                      callbackHandler.handle(new Callback[]{callback});
85                      callback.getResult();
86                  }
87                  catch (IOException e) {
88                      throw new TimestampValidationCallback.TimestampValidationException(e);
89                  }
90                  catch (UnsupportedCallbackException e) {
91                      // ignore
92                  }
93              }
94          }
95      }
96  
97      private class PasswordValidatorChain implements PasswordValidationCallback.PasswordValidator {
98  
99          private PasswordValidationCallback callback;
100 
101         private PasswordValidatorChain(PasswordValidationCallback callback) {
102             this.callback = callback;
103         }
104 
105         public boolean validate(PasswordValidationCallback.Request request)
106                 throws PasswordValidationCallback.PasswordValidationException {
107             boolean allUnsupported = true;
108             for (int i = 0; i < getCallbackHandlers().length; i++) {
109                 CallbackHandler callbackHandler = getCallbackHandlers()[i];
110                 try {
111                     callbackHandler.handle(new Callback[]{callback});
112                     allUnsupported = false;
113                     if (!callback.getResult()) {
114                         return false;
115                     }
116                 }
117                 catch (IOException e) {
118                     throw new PasswordValidationCallback.PasswordValidationException(e);
119                 }
120                 catch (UnsupportedCallbackException e) {
121                     // ignore
122                 }
123             }
124             return !allUnsupported;
125         }
126     }
127 
128     private class CertificateValidatorChain implements CertificateValidationCallback.CertificateValidator {
129 
130         private CertificateValidationCallback callback;
131 
132         private CertificateValidatorChain(CertificateValidationCallback callback) {
133             this.callback = callback;
134         }
135 
136         public boolean validate(X509Certificate certificate)
137                 throws CertificateValidationCallback.CertificateValidationException {
138             boolean allUnsupported = true;
139             for (int i = 0; i < getCallbackHandlers().length; i++) {
140                 CallbackHandler callbackHandler = getCallbackHandlers()[i];
141                 try {
142                     callbackHandler.handle(new Callback[]{callback});
143                     allUnsupported = false;
144                     if (!callback.getResult()) {
145                         return false;
146                     }
147                 }
148                 catch (IOException e) {
149                     throw new CertificateValidationCallback.CertificateValidationException(e);
150                 }
151                 catch (UnsupportedCallbackException e) {
152                     // ignore
153                 }
154             }
155             return !allUnsupported;
156         }
157     }
158 }