Formatting cleanups.
[java-idp.git] / tests / edu / internet2 / middleware / shibboleth / common / TrustTests.java
1 /*
2  * The Shibboleth License, Version 1. Copyright (c) 2002 University Corporation for Advanced Internet Development, Inc.
3  * All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted
4  * provided that the following conditions are met: Redistributions of source code must retain the above copyright
5  * notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above
6  * copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials
7  * provided with the distribution, if any, must include the following acknowledgment: "This product includes software
8  * developed by the University Corporation for Advanced Internet Development <http://www.ucaid.edu> Internet2 Project.
9  * Alternately, this acknowledegement may appear in the software itself, if and wherever such third-party
10  * acknowledgments normally appear. Neither the name of Shibboleth nor the names of its contributors, nor Internet2, nor
11  * the University Corporation for Advanced Internet Development, Inc., nor UCAID may be used to endorse or promote
12  * products derived from this software without specific prior written permission. For written permission, please contact
13  * shibboleth@shibboleth.org Products derived from this software may not be called Shibboleth, Internet2, UCAID, or the
14  * University Corporation for Advanced Internet Development, nor may Shibboleth appear in their name, without prior
15  * written permission of the University Corporation for Advanced Internet Development. THIS SOFTWARE IS PROVIDED BY THE
16  * COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND WITH ALL FAULTS. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE
18  * DISCLAIMED AND THE ENTIRE RISK OF SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS WITH LICENSEE. IN NO
19  * EVENT SHALL THE COPYRIGHT OWNER, CONTRIBUTORS OR THE UNIVERSITY CORPORATION FOR ADVANCED INTERNET DEVELOPMENT, INC.
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
23  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 package edu.internet2.middleware.shibboleth.common;
27
28 import java.io.File;
29 import java.io.IOException;
30 import java.security.KeyStore;
31 import java.security.KeyStoreException;
32 import java.security.NoSuchAlgorithmException;
33 import java.security.cert.CertificateException;
34 import java.security.cert.X509Certificate;
35
36 import junit.framework.TestCase;
37
38 import org.apache.log4j.BasicConfigurator;
39 import org.apache.log4j.Level;
40 import org.apache.log4j.Logger;
41
42 import edu.internet2.middleware.shibboleth.common.ShibResource.ResourceNotAvailableException;
43 import edu.internet2.middleware.shibboleth.common.provider.BasicTrust;
44 import edu.internet2.middleware.shibboleth.common.provider.ShibbolethTrust;
45 import edu.internet2.middleware.shibboleth.metadata.EntityDescriptor;
46 import edu.internet2.middleware.shibboleth.metadata.Metadata;
47 import edu.internet2.middleware.shibboleth.metadata.MetadataException;
48 import edu.internet2.middleware.shibboleth.metadata.SPSSODescriptor;
49 import edu.internet2.middleware.shibboleth.metadata.provider.XMLMetadata;
50 import edu.internet2.middleware.shibboleth.xml.Parser;
51
52 /**
53  * Test suite for SAML/Shibboleth trust validation.
54  * 
55  * @author Walter Hoehn
56  */
57 public class TrustTests extends TestCase {
58
59         private Parser.DOMParser parser = new Parser.DOMParser(true);
60
61         public TrustTests(String name) {
62
63                 super(name);
64                 BasicConfigurator.resetConfiguration();
65                 BasicConfigurator.configure();
66                 Logger.getRootLogger().setLevel(Level.OFF);
67         }
68
69         public static void main(String[] args) {
70
71                 junit.textui.TestRunner.run(CredentialsTests.class);
72                 BasicConfigurator.configure();
73                 Logger.getRootLogger().setLevel(Level.OFF);
74         }
75
76         protected void setUp() throws Exception {
77
78                 super.setUp();
79         }
80
81         public void testInlineX509CertValidate() {
82
83                 try {
84                         // Pull the role descriptor from example metadata
85                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
86                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
87                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
88                                         "urn:oasis:names:tc:SAML:1.1:protocol");
89
90                         // Use a pre-defined cert
91                         KeyStore keyStore = KeyStore.getInstance("JKS");
92                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
93                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
94                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
95
96                         // Try to validate against the metadata
97                         Trust validator = new BasicTrust();
98                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
99                         if (!successful) {
100                                 fail("Validation should have succeeded.");
101                         }
102
103                 } catch (MetadataException e) {
104                         fail("Error in test specification: " + e);
105                 } catch (ResourceNotAvailableException e) {
106                         fail("Error in test specification: " + e);
107                 } catch (IOException e) {
108                         fail("Error in test specification: " + e);
109                 } catch (NoSuchAlgorithmException e) {
110                         fail("Error in test specification: " + e);
111                 } catch (CertificateException e) {
112                         fail("Error in test specification: " + e);
113                 } catch (KeyStoreException e) {
114                         fail("Error in test specification: " + e);
115                 }
116         }
117
118         public void testInlineX509CertValidationFail() {
119
120                 try {
121                         // Pull the role descriptor from example metadata
122                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
123                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
124                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
125                                         "urn:oasis:names:tc:SAML:1.1:protocol");
126
127                         // Use a pre-defined cert
128                         KeyStore keyStore = KeyStore.getInstance("JKS");
129                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
130                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
131                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline2");
132
133                         // Try to validate against the metadata
134                         Trust validator = new BasicTrust();
135                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
136                         if (successful) {
137                                 fail("Validation should have failed.");
138                         }
139
140                 } catch (MetadataException e) {
141                         fail("Error in test specification: " + e);
142                 } catch (ResourceNotAvailableException e) {
143                         fail("Error in test specification: " + e);
144                 } catch (IOException e) {
145                         fail("Error in test specification: " + e);
146                 } catch (NoSuchAlgorithmException e) {
147                         fail("Error in test specification: " + e);
148                 } catch (CertificateException e) {
149                         fail("Error in test specification: " + e);
150                 } catch (KeyStoreException e) {
151                         fail("Error in test specification: " + e);
152                 }
153         }
154
155         public void testPkixX509CertValidate() {
156
157                 try {
158                         // Pull the role descriptor from example metadata
159                         Metadata metadata = new XMLMetadata(new File("data/metadata2.xml").toURL().toString());
160                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
161                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
162                                         "urn:oasis:names:tc:SAML:1.1:protocol");
163
164                         // Use a pre-defined cert
165                         KeyStore keyStore = KeyStore.getInstance("JKS");
166                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
167                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
168                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
169
170                         // Try to validate against the metadata
171                         Trust validator = new ShibbolethTrust();
172                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
173                         if (!successful) {
174                                 fail("Validation should have succeeded.");
175                         }
176
177                 } catch (MetadataException e) {
178                         fail("Error in test specification: " + e);
179                 } catch (ResourceNotAvailableException e) {
180                         fail("Error in test specification: " + e);
181                 } catch (IOException e) {
182                         fail("Error in test specification: " + e);
183                 } catch (NoSuchAlgorithmException e) {
184                         fail("Error in test specification: " + e);
185                 } catch (CertificateException e) {
186                         fail("Error in test specification: " + e);
187                 } catch (KeyStoreException e) {
188                         fail("Error in test specification: " + e);
189                 }
190         }
191
192         public void testPkixX509CertValidateRecurseEntities() {
193
194                 try {
195                         // Pull the role descriptor from example metadata
196                         Metadata metadata = new XMLMetadata(new File("data/metadata3.xml").toURL().toString());
197                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
198                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
199                                         "urn:oasis:names:tc:SAML:1.1:protocol");
200
201                         // Use a pre-defined cert
202                         KeyStore keyStore = KeyStore.getInstance("JKS");
203                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
204                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
205                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
206
207                         // Try to validate against the metadata
208                         Trust validator = new ShibbolethTrust();
209                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
210                         if (!successful) {
211                                 fail("Validation should have succeeded.");
212                         }
213
214                 } catch (MetadataException e) {
215                         fail("Error in test specification: " + e);
216                 } catch (ResourceNotAvailableException e) {
217                         fail("Error in test specification: " + e);
218                 } catch (IOException e) {
219                         fail("Error in test specification: " + e);
220                 } catch (NoSuchAlgorithmException e) {
221                         fail("Error in test specification: " + e);
222                 } catch (CertificateException e) {
223                         fail("Error in test specification: " + e);
224                 } catch (KeyStoreException e) {
225                         fail("Error in test specification: " + e);
226                 }
227         }
228
229         public void testPkixX509CertValidateWithCAPath() {
230
231                 try {
232                         // Pull the role descriptor from example metadata
233                         Metadata metadata = new XMLMetadata(new File("data/metadata4.xml").toURL().toString());
234                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
235                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
236                                         "urn:oasis:names:tc:SAML:1.1:protocol");
237
238                         // Use a pre-defined cert
239                         KeyStore keyStore = KeyStore.getInstance("JKS");
240                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
241                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
242                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline3");
243
244                         // Try to validate against the metadata
245                         Trust validator = new ShibbolethTrust();
246                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
247                         if (!successful) {
248                                 fail("Validation should have succeeded.");
249                         }
250
251                 } catch (MetadataException e) {
252                         fail("Error in test specification: " + e);
253                 } catch (ResourceNotAvailableException e) {
254                         fail("Error in test specification: " + e);
255                 } catch (IOException e) {
256                         fail("Error in test specification: " + e);
257                 } catch (NoSuchAlgorithmException e) {
258                         fail("Error in test specification: " + e);
259                 } catch (CertificateException e) {
260                         fail("Error in test specification: " + e);
261                 } catch (KeyStoreException e) {
262                         fail("Error in test specification: " + e);
263                 }
264         }
265
266         public void testPkixX509CertFailValidateWithPathTooLong() {
267
268                 try {
269                         // Pull the role descriptor from example metadata
270                         Metadata metadata = new XMLMetadata(new File("data/metadata6.xml").toURL().toString());
271                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
272                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
273                                         "urn:oasis:names:tc:SAML:1.1:protocol");
274
275                         // Use a pre-defined cert
276                         KeyStore keyStore = KeyStore.getInstance("JKS");
277                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
278                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
279                         X509Certificate endEntity = (X509Certificate) keyStore.getCertificate("inline3");
280                         X509Certificate intermediate = (X509Certificate) keyStore.getCertificate("im");
281
282                         // Try to validate against the metadata
283                         Trust validator = new ShibbolethTrust();
284                         boolean successful = validator.validate(endEntity, new X509Certificate[]{endEntity, intermediate}, role);
285                         if (successful) {
286                                 fail("Validation should not have succeeded.");
287                         }
288
289                 } catch (MetadataException e) {
290                         fail("Error in test specification: " + e);
291                 } catch (ResourceNotAvailableException e) {
292                         fail("Error in test specification: " + e);
293                 } catch (IOException e) {
294                         fail("Error in test specification: " + e);
295                 } catch (NoSuchAlgorithmException e) {
296                         fail("Error in test specification: " + e);
297                 } catch (CertificateException e) {
298                         fail("Error in test specification: " + e);
299                 } catch (KeyStoreException e) {
300                         fail("Error in test specification: " + e);
301                 }
302         }
303
304         public void testPkixX509CertValidateWithClientSuppliedIntermediate() {
305
306                 try {
307                         // Pull the role descriptor from example metadata
308                         Metadata metadata = new XMLMetadata(new File("data/metadata5.xml").toURL().toString());
309                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
310                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
311                                         "urn:oasis:names:tc:SAML:1.1:protocol");
312
313                         // Use a pre-defined cert
314                         KeyStore keyStore = KeyStore.getInstance("JKS");
315                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
316                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
317                         X509Certificate endEntity = (X509Certificate) keyStore.getCertificate("inline3");
318                         X509Certificate intermediate = (X509Certificate) keyStore.getCertificate("im");
319
320                         // Try to validate against the metadata
321                         Trust validator = new ShibbolethTrust();
322                         boolean successful = validator.validate(endEntity, new X509Certificate[]{endEntity, intermediate}, role);
323                         if (!successful) {
324                                 fail("Validation should have succeeded.");
325                         }
326
327                 } catch (MetadataException e) {
328                         fail("Error in test specification: " + e);
329                 } catch (ResourceNotAvailableException e) {
330                         fail("Error in test specification: " + e);
331                 } catch (IOException e) {
332                         fail("Error in test specification: " + e);
333                 } catch (NoSuchAlgorithmException e) {
334                         fail("Error in test specification: " + e);
335                 } catch (CertificateException e) {
336                         fail("Error in test specification: " + e);
337                 } catch (KeyStoreException e) {
338                         fail("Error in test specification: " + e);
339                 }
340         }
341
342         public void testCRL() {
343
344                 try {
345                         // Pull the role descriptor from example metadata
346                         Metadata metadata = new XMLMetadata(new File("data/metadata7.xml").toURL().toString());
347                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
348                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
349                                         "urn:oasis:names:tc:SAML:1.1:protocol");
350
351                         // Use a pre-defined cert
352                         KeyStore keyStore = KeyStore.getInstance("JKS");
353                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
354                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
355                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline4");
356
357                         // Try to validate against the metadata
358                         Trust validator = new ShibbolethTrust();
359                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
360                         if (successful) {
361                                 fail("Validation should not have succeeded.");
362                         }
363
364                 } catch (MetadataException e) {
365                         fail("Error in test specification: " + e);
366                 } catch (ResourceNotAvailableException e) {
367                         fail("Error in test specification: " + e);
368                 } catch (IOException e) {
369                         fail("Error in test specification: " + e);
370                 } catch (NoSuchAlgorithmException e) {
371                         fail("Error in test specification: " + e);
372                 } catch (CertificateException e) {
373                         fail("Error in test specification: " + e);
374                 } catch (KeyStoreException e) {
375                         fail("Error in test specification: " + e);
376                 }
377         }
378
379         public void testCRLDoesntBreakValid() {
380
381                 try {
382                         // Pull the role descriptor from example metadata
383                         Metadata metadata = new XMLMetadata(new File("data/metadata8.xml").toURL().toString());
384                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
385                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
386                                         "urn:oasis:names:tc:SAML:1.1:protocol");
387
388                         // Use a pre-defined cert
389                         KeyStore keyStore = KeyStore.getInstance("JKS");
390                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
391                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
392                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline4");
393
394                         // Try to validate against the metadata
395                         Trust validator = new ShibbolethTrust();
396                         boolean successful = validator.validate(cert, new X509Certificate[]{cert}, role);
397                         if (!successful) {
398                                 fail("Validation should have succeeded.");
399                         }
400
401                 } catch (MetadataException e) {
402                         fail("Error in test specification: " + e);
403                 } catch (ResourceNotAvailableException e) {
404                         fail("Error in test specification: " + e);
405                 } catch (IOException e) {
406                         fail("Error in test specification: " + e);
407                 } catch (NoSuchAlgorithmException e) {
408                         fail("Error in test specification: " + e);
409                 } catch (CertificateException e) {
410                         fail("Error in test specification: " + e);
411                 } catch (KeyStoreException e) {
412                         fail("Error in test specification: " + e);
413                 }
414         }
415 }