tests/edu/internet2/middleware/shibboleth/common/TrustTests.java

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