More 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.metadata.EntityDescriptor;
44 import edu.internet2.middleware.shibboleth.metadata.KeyDescriptor;
45 import edu.internet2.middleware.shibboleth.metadata.Metadata;
46 import edu.internet2.middleware.shibboleth.metadata.MetadataException;
47 import edu.internet2.middleware.shibboleth.metadata.SPSSODescriptor;
48 import edu.internet2.middleware.shibboleth.metadata.provider.XMLMetadata;
49 import edu.internet2.middleware.shibboleth.xml.Parser;
50
51 /**
52  * Test suite for SAML/Shibboleth trust validation.
53  * 
54  * @author Walter Hoehn
55  */
56 public class TrustTests extends TestCase {
57
58         private Parser.DOMParser parser = new Parser.DOMParser(true);
59
60         public TrustTests(String name) {
61
62                 super(name);
63                 BasicConfigurator.resetConfiguration();
64                 BasicConfigurator.configure();
65                 Logger.getRootLogger().setLevel(Level.OFF);
66         }
67
68         public static void main(String[] args) {
69
70                 junit.textui.TestRunner.run(CredentialsTests.class);
71                 BasicConfigurator.configure();
72                 Logger.getRootLogger().setLevel(Level.OFF);
73         }
74
75         protected void setUp() throws Exception {
76
77                 super.setUp();
78         }
79
80         public void testInlineX509CertValidate() {
81
82                 try {
83                         // Pull the role descriptor from example metadata
84                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
85                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
86                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
87                                         "urn:oasis:names:tc:SAML:1.1:protocol");
88
89                         // Use a pre-defined cert
90                         KeyStore keyStore = KeyStore.getInstance("JKS");
91                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
92                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
93                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
94
95                         // Try to validate against the metadata
96                         Trust validator = new Trust();
97                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
98                         if (!successful) {
99                                 fail("Validation should have succeeded.");
100                         }
101
102                 } catch (MetadataException e) {
103                         fail("Error in test specification: " + e);
104                 } catch (ResourceNotAvailableException e) {
105                         fail("Error in test specification: " + e);
106                 } catch (IOException e) {
107                         fail("Error in test specification: " + e);
108                 } catch (NoSuchAlgorithmException e) {
109                         fail("Error in test specification: " + e);
110                 } catch (CertificateException e) {
111                         fail("Error in test specification: " + e);
112                 } catch (KeyStoreException e) {
113                         fail("Error in test specification: " + e);
114                 }
115         }
116
117         public void testInlineX509CertValidationFail() {
118
119                 try {
120                         // Pull the role descriptor from example metadata
121                         Metadata metadata = new XMLMetadata(new File("data/metadata1.xml").toURL().toString());
122                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
123                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
124                                         "urn:oasis:names:tc:SAML:1.1:protocol");
125
126                         // Use a pre-defined cert
127                         KeyStore keyStore = KeyStore.getInstance("JKS");
128                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
129                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
130                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline2");
131
132                         // Try to validate against the metadata
133                         Trust validator = new Trust();
134                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
135                         if (successful) {
136                                 fail("Validation should have failed.");
137                         }
138
139                 } catch (MetadataException e) {
140                         fail("Error in test specification: " + e);
141                 } catch (ResourceNotAvailableException e) {
142                         fail("Error in test specification: " + e);
143                 } catch (IOException e) {
144                         fail("Error in test specification: " + e);
145                 } catch (NoSuchAlgorithmException e) {
146                         fail("Error in test specification: " + e);
147                 } catch (CertificateException e) {
148                         fail("Error in test specification: " + e);
149                 } catch (KeyStoreException e) {
150                         fail("Error in test specification: " + e);
151                 }
152         }
153
154         public void testPkixX509CertValidate() {
155
156                 try {
157                         // Pull the role descriptor from example metadata
158                         Metadata metadata = new XMLMetadata(new File("data/metadata2.xml").toURL().toString());
159                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
160                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
161                                         "urn:oasis:names:tc:SAML:1.1:protocol");
162
163                         // Use a pre-defined cert
164                         KeyStore keyStore = KeyStore.getInstance("JKS");
165                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
166                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
167                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
168
169                         // Try to validate against the metadata
170                         Trust validator = new ShibbolethTrust();
171                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
172                         if (!successful) {
173                                 fail("Validation should have succeeded.");
174                         }
175
176                 } catch (MetadataException e) {
177                         fail("Error in test specification: " + e);
178                 } catch (ResourceNotAvailableException e) {
179                         fail("Error in test specification: " + e);
180                 } catch (IOException e) {
181                         fail("Error in test specification: " + e);
182                 } catch (NoSuchAlgorithmException e) {
183                         fail("Error in test specification: " + e);
184                 } catch (CertificateException e) {
185                         fail("Error in test specification: " + e);
186                 } catch (KeyStoreException e) {
187                         fail("Error in test specification: " + e);
188                 }
189         }
190
191         public void testPkixX509CertValidateRecurseEntities() {
192
193                 try {
194                         // Pull the role descriptor from example metadata
195                         Metadata metadata = new XMLMetadata(new File("data/metadata3.xml").toURL().toString());
196                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
197                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
198                                         "urn:oasis:names:tc:SAML:1.1:protocol");
199
200                         // Use a pre-defined cert
201                         KeyStore keyStore = KeyStore.getInstance("JKS");
202                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
203                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
204                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inliine1");
205
206                         // Try to validate against the metadata
207                         Trust validator = new ShibbolethTrust();
208                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
209                         if (!successful) {
210                                 fail("Validation should have succeeded.");
211                         }
212
213                 } catch (MetadataException e) {
214                         fail("Error in test specification: " + e);
215                 } catch (ResourceNotAvailableException e) {
216                         fail("Error in test specification: " + e);
217                 } catch (IOException e) {
218                         fail("Error in test specification: " + e);
219                 } catch (NoSuchAlgorithmException e) {
220                         fail("Error in test specification: " + e);
221                 } catch (CertificateException e) {
222                         fail("Error in test specification: " + e);
223                 } catch (KeyStoreException e) {
224                         fail("Error in test specification: " + e);
225                 }
226         }
227
228         public void testPkixX509CertValidateWithCAPath() {
229
230                 try {
231                         // Pull the role descriptor from example metadata
232                         Metadata metadata = new XMLMetadata(new File("data/metadata4.xml").toURL().toString());
233                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
234                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
235                                         "urn:oasis:names:tc:SAML:1.1:protocol");
236
237                         // Use a pre-defined cert
238                         KeyStore keyStore = KeyStore.getInstance("JKS");
239                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
240                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
241                         X509Certificate cert = (X509Certificate) keyStore.getCertificate("inline3");
242
243                         // Try to validate against the metadata
244                         Trust validator = new ShibbolethTrust();
245                         boolean successful = validator.validate(role, new X509Certificate[]{cert}, KeyDescriptor.ENCRYPTION);
246                         if (!successful) {
247                                 fail("Validation should have succeeded.");
248                         }
249
250                 } catch (MetadataException e) {
251                         fail("Error in test specification: " + e);
252                 } catch (ResourceNotAvailableException e) {
253                         fail("Error in test specification: " + e);
254                 } catch (IOException e) {
255                         fail("Error in test specification: " + e);
256                 } catch (NoSuchAlgorithmException e) {
257                         fail("Error in test specification: " + e);
258                 } catch (CertificateException e) {
259                         fail("Error in test specification: " + e);
260                 } catch (KeyStoreException e) {
261                         fail("Error in test specification: " + e);
262                 }
263         }
264         
265         public void testPkixX509CertFailValidateWithPathTooLong() {
266
267                 try {
268                         // Pull the role descriptor from example metadata
269                         Metadata metadata = new XMLMetadata(new File("data/metadata6.xml").toURL().toString());
270                         EntityDescriptor entity = metadata.lookup("urn-x:testSP1");
271                         SPSSODescriptor role = (SPSSODescriptor) entity.getRoleByType(SPSSODescriptor.class,
272                                         "urn:oasis:names:tc:SAML:1.1:protocol");
273
274                         // Use a pre-defined cert
275                         KeyStore keyStore = KeyStore.getInstance("JKS");
276                         keyStore.load(new ShibResource(new File("data/trusttest.jks").toURL().toString()).getInputStream(),
277                                         new char[]{'t', 'e', 's', 't', '1', '2', '3'});
278                         X509Certificate endEntity = (X509Certificate) keyStore.getCertificate("inline3");
279                         X509Certificate intermediate = (X509Certificate) keyStore.getCertificate("im");
280
281                         // Try to validate against the metadata
282                         Trust validator = new ShibbolethTrust();
283                         boolean successful = validator.validate(role, new X509Certificate[]{endEntity, intermediate},
284                                         KeyDescriptor.ENCRYPTION);
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(role, new X509Certificate[]{endEntity, intermediate},
323                                         KeyDescriptor.ENCRYPTION);
324                         if (!successful) {
325                                 fail("Validation should have succeeded.");
326                         }
327
328                 } catch (MetadataException e) {
329                         fail("Error in test specification: " + e);
330                 } catch (ResourceNotAvailableException e) {
331                         fail("Error in test specification: " + e);
332                 } catch (IOException e) {
333                         fail("Error in test specification: " + e);
334                 } catch (NoSuchAlgorithmException e) {
335                         fail("Error in test specification: " + e);
336                 } catch (CertificateException e) {
337                         fail("Error in test specification: " + e);
338                 } catch (KeyStoreException e) {
339                         fail("Error in test specification: " + e);
340                 }
341         }
342 }