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