Inline CRLs in the metadata are now honored during pkix validation. Junit tests...
[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.KeyDescriptor;
47 import edu.internet2.middleware.shibboleth.metadata.Metadata;
48 import edu.internet2.middleware.shibboleth.metadata.MetadataException;
49 import edu.internet2.middleware.shibboleth.metadata.SPSSODescriptor;
50 import edu.internet2.middleware.shibboleth.metadata.provider.XMLMetadata;
51 import edu.internet2.middleware.shibboleth.xml.Parser;
52
53 /**
54  * Test suite for SAML/Shibboleth trust validation.
55  * 
56  * @author Walter Hoehn
57  */
58 public class TrustTests extends TestCase {
59
60         private Parser.DOMParser parser = new Parser.DOMParser(true);
61
62         public TrustTests(String name) {
63
64                 super(name);
65                 BasicConfigurator.resetConfiguration();
66                 BasicConfigurator.configure();
67                 Logger.getRootLogger().setLevel(Level.OFF);
68         }
69
70         public static void main(String[] args) {
71
72                 junit.textui.TestRunner.run(CredentialsTests.class);
73                 BasicConfigurator.configure();
74                 Logger.getRootLogger().setLevel(Level.OFF);
75         }
76
77         protected void setUp() throws Exception {
78
79                 super.setUp();
80         }
81
82         public void testInlineX509CertValidate() {
83
84                 try {
85                         // Pull the role descriptor from example metadata
86                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
87                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
88                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
89                                         "urn:oasis:names:tc:SAML:1.1:protocol");
90
91                         // Use a pre-defined cert
92                         KeyStore keyStore = KeyStore.getInstance("JKS");
93                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
94                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
95                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
96
97                         // Try to validate against the metadata
98                         Trust validator = new BasicTrust();
99                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
100                         if (!successful) {
101                                 fail("Validation should have succeeded.");
102                         }
103
104                 } catch (MetadataException e) {
105                         fail("Error in test specification: " + e);
106                 } catch (ResourceNotAvailableException e) {
107                         fail("Error in test specification: " + e);
108                 } catch (IOException e) {
109                         fail("Error in test specification: " + e);
110                 } catch (NoSuchAlgorithmException e) {
111                         fail("Error in test specification: " + e);
112                 } catch (CertificateException e) {
113                         fail("Error in test specification: " + e);
114                 } catch (KeyStoreException e) {
115                         fail("Error in test specification: " + e);
116                 }
117         }
118
119         public void testInlineX509CertValidationFail() {
120
121                 try {
122                         // Pull the role descriptor from example metadata
123                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
124                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
125                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
126                                         "urn:oasis:names:tc:SAML:1.1:protocol");
127
128                         // Use a pre-defined cert
129                         KeyStore keyStore = KeyStore.getInstance("JKS");
130                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
131                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
132                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline2");
133
134                         // Try to validate against the metadata
135                         Trust validator = new BasicTrust();
136                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
137                         if (successful) {
138                                 fail("Validation should have failed.");
139                         }
140
141                 } catch (MetadataException e) {
142                         fail("Error in test specification: " + e);
143                 } catch (ResourceNotAvailableException e) {
144                         fail("Error in test specification: " + e);
145                 } catch (IOException e) {
146                         fail("Error in test specification: " + e);
147                 } catch (NoSuchAlgorithmException e) {
148                         fail("Error in test specification: " + e);
149                 } catch (CertificateException e) {
150                         fail("Error in test specification: " + e);
151                 } catch (KeyStoreException e) {
152                         fail("Error in test specification: " + e);
153                 }
154         }
155
156         public void testPkixX509CertValidate() {
157
158                 try {
159                         // Pull the role descriptor from example metadata
160                         Metadata metadata = new XMLMetadata(new File("data/metadata2.xml").toURL().toString());
161                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
162                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
163                                         "urn:oasis:names:tc:SAML:1.1:protocol");
164
165                         // Use a pre-defined cert
166                         KeyStore keyStore = KeyStore.getInstance("JKS");
167                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
168                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
169                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
170
171                         // Try to validate against the metadata
172                         Trust validator = new ShibbolethTrust();
173                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
174                         if (!successful) {
175                                 fail("Validation should have succeeded.");
176                         }
177
178                 } catch (MetadataException e) {
179                         fail("Error in test specification: " + e);
180                 } catch (ResourceNotAvailableException e) {
181                         fail("Error in test specification: " + e);
182                 } catch (IOException e) {
183                         fail("Error in test specification: " + e);
184                 } catch (NoSuchAlgorithmException e) {
185                         fail("Error in test specification: " + e);
186                 } catch (CertificateException e) {
187                         fail("Error in test specification: " + e);
188                 } catch (KeyStoreException e) {
189                         fail("Error in test specification: " + e);
190                 }
191         }
192
193         public void testPkixX509CertValidateRecurseEntities() {
194
195                 try {
196                         // Pull the role descriptor from example metadata
197                         Metadata metadata = new XMLMetadata(new File("data/metadata3.xml").toURL().toString());
198                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
199                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
200                                         "urn:oasis:names:tc:SAML:1.1:protocol");
201
202                         // Use a pre-defined cert
203                         KeyStore keyStore = KeyStore.getInstance("JKS");
204                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
205                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
206                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
207
208                         // Try to validate against the metadata
209                         Trust validator = new ShibbolethTrust();
210                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
211                         if (!successful) {
212                                 fail("Validation should have succeeded.");
213                         }
214
215                 } catch (MetadataException e) {
216                         fail("Error in test specification: " + e);
217                 } catch (ResourceNotAvailableException e) {
218                         fail("Error in test specification: " + e);
219                 } catch (IOException e) {
220                         fail("Error in test specification: " + e);
221                 } catch (NoSuchAlgorithmException e) {
222                         fail("Error in test specification: " + e);
223                 } catch (CertificateException e) {
224                         fail("Error in test specification: " + e);
225                 } catch (KeyStoreException e) {
226                         fail("Error in test specification: " + e);
227                 }
228         }
229
230         public void testPkixX509CertValidateWithCAPath() {
231
232                 try {
233                         // Pull the role descriptor from example metadata
234                         Metadata metadata = new XMLMetadata(new File("data/metadata4.xml").toURL().toString());
235                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
236                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
237                                         "urn:oasis:names:tc:SAML:1.1:protocol");
238
239                         // Use a pre-defined cert
240                         KeyStore keyStore = KeyStore.getInstance("JKS");
241                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
242                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
243                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline3");
244
245                         // Try to validate against the metadata
246                         Trust validator = new ShibbolethTrust();
247                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
248                         if (!successful) {
249                                 fail("Validation should have succeeded.");
250                         }
251
252                 } catch (MetadataException e) {
253                         fail("Error in test specification: " + e);
254                 } catch (ResourceNotAvailableException e) {
255                         fail("Error in test specification: " + e);
256                 } catch (IOException e) {
257                         fail("Error in test specification: " + e);
258                 } catch (NoSuchAlgorithmException e) {
259                         fail("Error in test specification: " + e);
260                 } catch (CertificateException e) {
261                         fail("Error in test specification: " + e);
262                 } catch (KeyStoreException e) {
263                         fail("Error in test specification: " + e);
264                 }
265         }
266
267         public void testPkixX509CertFailValidateWithPathTooLong() {
268
269                 try {
270                         // Pull the role descriptor from example metadata
271                         Metadata metadata = new XMLMetadata(new File("data/metadata6.xml").toURL().toString());
272                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
273                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
274                                         "urn:oasis:names:tc:SAML:1.1:protocol");
275
276                         // Use a pre-defined cert
277                         KeyStore keyStore = KeyStore.getInstance("JKS");
278                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
279                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
280                         X509Certificate endEntity = (X509Certificate) keyStore.getCertificate("inline3");
281                         X509Certificate intermediate = (X509Certificate) keyStore.getCertificate("im");
282
283                         // Try to validate against the metadata
284                         Trust validator = new ShibbolethTrust();
285                         boolean successful = validator.validate(role, new X509Certificate[]{endEntity, intermediate},
286                                         KeyDescriptor.ENCRYPTION);
287                         if (successful) {
288                                 fail("Validation should not have succeeded.");
289                         }
290
291                 } catch (MetadataException e) {
292                         fail("Error in test specification: " + e);
293                 } catch (ResourceNotAvailableException e) {
294                         fail("Error in test specification: " + e);
295                 } catch (IOException e) {
296                         fail("Error in test specification: " + e);
297                 } catch (NoSuchAlgorithmException e) {
298                         fail("Error in test specification: " + e);
299                 } catch (CertificateException e) {
300                         fail("Error in test specification: " + e);
301                 } catch (KeyStoreException e) {
302                         fail("Error in test specification: " + e);
303                 }
304         }
305
306         public void testPkixX509CertValidateWithClientSuppliedIntermediate() {
307
308                 try {
309                         // Pull the role descriptor from example metadata
310                         Metadata metadata = new XMLMetadata(new File("data/metadata5.xml").toURL().toString());
311                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
312                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
313                                         "urn:oasis:names:tc:SAML:1.1:protocol");
314
315                         // Use a pre-defined cert
316                         KeyStore keyStore = KeyStore.getInstance("JKS");
317                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
318                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
319                         X509Certificate endEntity = (X509Certificate) keyStore.getCertificate("inline3");
320                         X509Certificate intermediate = (X509Certificate) keyStore.getCertificate("im");
321
322                         // Try to validate against the metadata
323                         Trust validator = new ShibbolethTrust();
324                         boolean successful = validator.validate(role, new X509Certificate[]{endEntity, intermediate},
325                                         KeyDescriptor.ENCRYPTION);
326                         if (!successful) {
327                                 fail("Validation should have succeeded.");
328                         }
329
330                 } catch (MetadataException e) {
331                         fail("Error in test specification: " + e);
332                 } catch (ResourceNotAvailableException e) {
333                         fail("Error in test specification: " + e);
334                 } catch (IOException e) {
335                         fail("Error in test specification: " + e);
336                 } catch (NoSuchAlgorithmException e) {
337                         fail("Error in test specification: " + e);
338                 } catch (CertificateException e) {
339                         fail("Error in test specification: " + e);
340                 } catch (KeyStoreException e) {
341                         fail("Error in test specification: " + e);
342                 }
343         }
344
345         public void testCRL() {
346
347                 try {
348                         // Pull the role descriptor from example metadata
349                         Metadata metadata = new XMLMetadata(new File("data/metadata7.xml").toURL().toString());
350                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
351                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
352                                         "urn:oasis:names:tc:SAML:1.1:protocol");
353
354                         // Use a pre-defined cert
355                         KeyStore keyStore = KeyStore.getInstance("JKS");
356                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
357                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
358                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline4");
359
360                         // Try to validate against the metadata
361                         Trust validator = new ShibbolethTrust();
362                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
363                         if (successful) {
364                                 fail("Validation should not have succeeded.");
365                         }
366
367                 } catch (MetadataException e) {
368                         fail("Error in test specification: " + e);
369                 } catch (ResourceNotAvailableException e) {
370                         fail("Error in test specification: " + e);
371                 } catch (IOException e) {
372                         fail("Error in test specification: " + e);
373                 } catch (NoSuchAlgorithmException e) {
374                         fail("Error in test specification: " + e);
375                 } catch (CertificateException e) {
376                         fail("Error in test specification: " + e);
377                 } catch (KeyStoreException e) {
378                         fail("Error in test specification: " + e);
379                 }
380         }
381
382         public void testCRLDoesntBreakValid() {
383
384                 try {
385                         // Pull the role descriptor from example metadata
386                         Metadata metadata = new XMLMetadata(new File("data/metadata8.xml").toURL().toString());
387                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
388                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
389                                         "urn:oasis:names:tc:SAML:1.1:protocol");
390
391                         // Use a pre-defined cert
392                         KeyStore keyStore = KeyStore.getInstance("JKS");
393                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
394                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
395                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline4");
396
397                         // Try to validate against the metadata
398                         Trust validator = new ShibbolethTrust();
399                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
400                         if (!successful) {
401                                 fail("Validation should have succeeded.");
402                         }
403
404                 } catch (MetadataException e) {
405                         fail("Error in test specification: " + e);
406                 } catch (ResourceNotAvailableException e) {
407                         fail("Error in test specification: " + e);
408                 } catch (IOException e) {
409                         fail("Error in test specification: " + e);
410                 } catch (NoSuchAlgorithmException e) {
411                         fail("Error in test specification: " + e);
412                 } catch (CertificateException e) {
413                         fail("Error in test specification: " + e);
414                 } catch (KeyStoreException e) {
415                         fail("Error in test specification: " + e);
416                 }
417         }
418 }