Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.taverna.security.credentialmanager.impl; import static org.junit.Assert.*; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.security.Key; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.Security; import java.security.UnrecoverableKeyException; import java.security.cert.Certificate; import java.security.cert.CertificateException; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.Arrays; import java.util.Enumeration; import java.util.List; import java.util.Random; import javax.net.ssl.SSLSocketFactory; import org.apache.taverna.lang.observer.Observable; import org.apache.taverna.lang.observer.Observer; import org.apache.taverna.security.credentialmanager.CMException; import org.apache.taverna.security.credentialmanager.CredentialManager; import org.apache.taverna.security.credentialmanager.CredentialManager.KeystoreType; import org.apache.taverna.security.credentialmanager.JavaTruststorePasswordProvider; import org.apache.taverna.security.credentialmanager.KeystoreChangedEvent; import org.apache.taverna.security.credentialmanager.MasterPasswordProvider; import org.apache.taverna.security.credentialmanager.ServiceUsernameAndPasswordProvider; import org.apache.taverna.security.credentialmanager.TrustConfirmationProvider; import org.apache.taverna.security.credentialmanager.UsernamePassword; import org.apache.commons.io.FileUtils; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; /** * Tests here should not require Java strong/unlimited cryptography policy to be installed, * although if something goes wrong that is the first thing to be checked for. * * Java by default comes with the weak policy * that disables the use of certain cryto algorithms and bigger key sizes. Although * it is claimed that as of Java 6 the default policy is strong, we have seen otherwise, * so make sure you install it. * * For Java 6, strong/unlimited cryptography policy can be downloaded * (together with the installation instructions) from: * http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html * * An empty Keystore/Truststore is created before each test so we always start afresh * (see the setUp() method). * s * @author Alex Nenadic * */ public class CredentialManagerImplTest { private CredentialManagerImpl credentialManager; private String masterPassword = "uber"; private DummyMasterPasswordProvider masterPasswordProvider; private File credentialManagerDirectory; private static UsernamePassword usernamePassword; private static URI serviceURI; private static Key privateKey; private static Certificate[] privateKeyCertChain; private static URL privateKeyFileURL = CredentialManagerImplTest.class .getResource("/security/test-private-key-cert.p12"); private static final String privateKeyAndPKCS12KeystorePassword = "test"; // password for the test PKCS#12 keystore in resources private static X509Certificate trustedCertficate; private static URL trustedCertficateFileURL = CredentialManagerImplTest.class .getResource("/security/google-trusted-certificate.pem"); private static Observer<KeystoreChangedEvent> keystoreChangedObserver; /** * @throws java.lang.Exception */ @BeforeClass public static void setUpBeforeClass() throws Exception { // Just in case, add the BouncyCastle provider // It gets added from the CredentialManagerImpl constructor as well // but we may need some crypto operations before we invoke the Cred. Manager Security.addProvider(new BouncyCastleProvider()); // Create a test username and password for a service serviceURI = new URI("http://someservice"); usernamePassword = new UsernamePassword("testuser", "testpasswd"); // Load the test private key and its certificate File privateKeyCertFile = new File(privateKeyFileURL.getPath()); KeyStore pkcs12Keystore = java.security.KeyStore.getInstance("PKCS12", "BC"); // We have to use the BC provider here as the certificate chain is not loaded if we use whichever provider is first in Java!!! FileInputStream inStream = new FileInputStream(privateKeyCertFile); pkcs12Keystore.load(inStream, privateKeyAndPKCS12KeystorePassword.toCharArray()); // KeyStore pkcs12Keystore = credentialManager.loadPKCS12Keystore(privateKeyCertFile, privateKeyPassword); Enumeration<String> aliases = pkcs12Keystore.aliases(); while (aliases.hasMoreElements()) { // The test-private-key-cert.p12 file contains only one private key // and corresponding certificate entry String alias = aliases.nextElement(); if (pkcs12Keystore.isKeyEntry(alias)) { // is it a (private) key entry? privateKey = pkcs12Keystore.getKey(alias, privateKeyAndPKCS12KeystorePassword.toCharArray()); privateKeyCertChain = pkcs12Keystore.getCertificateChain(alias); break; } } inStream.close(); // Load the test trusted certificate (belonging to *.Google.com) File trustedCertFile = new File(trustedCertficateFileURL.getPath()); inStream = new FileInputStream(trustedCertFile); CertificateFactory certFactory = CertificateFactory.getInstance("X.509"); trustedCertficate = (X509Certificate) certFactory.generateCertificate(inStream); try { inStream.close(); } catch (Exception e) { // Ignore } keystoreChangedObserver = new Observer<KeystoreChangedEvent>() { @Override public void notify(Observable<KeystoreChangedEvent> sender, KeystoreChangedEvent message) throws Exception { // TODO Auto-generated method stub } }; } /** * @throws java.lang.Exception */ @Before public void setUp() throws Exception { try { credentialManager = new CredentialManagerImpl(); } catch (CMException e) { System.out.println(e.getStackTrace()); } Random randomGenerator = new Random(); String credentialManagerDirectoryPath = System.getProperty("java.io.tmpdir") + System.getProperty("file.separator") + "taverna-security-" + randomGenerator.nextInt(1000000); System.out.println("Credential Manager's directory path: " + credentialManagerDirectoryPath); credentialManagerDirectory = new File(credentialManagerDirectoryPath); try { credentialManager.setConfigurationDirectoryPath(credentialManagerDirectory.toPath()); } catch (CMException e) { System.out.println(e.getStackTrace()); } // Create the dummy master password provider masterPasswordProvider = new DummyMasterPasswordProvider(); masterPasswordProvider.setMasterPassword(masterPassword); List<MasterPasswordProvider> masterPasswordProviders = new ArrayList<MasterPasswordProvider>(); masterPasswordProviders.add(masterPasswordProvider); credentialManager.setMasterPasswordProviders(masterPasswordProviders); // Set an empty list for service username and password providers credentialManager .setServiceUsernameAndPasswordProviders(new ArrayList<ServiceUsernameAndPasswordProvider>()); credentialManager.setJavaTruststorePasswordProviders(new ArrayList<JavaTruststorePasswordProvider>()); credentialManager.setTrustConfirmationProviders(new ArrayList<TrustConfirmationProvider>()); } @After // Clean up the credentialManagerDirectory we created for testing public void cleanUp() { // assertTrue(credentialManagerDirectory.exists()); // assertFalse(credentialManagerDirectory.listFiles().length == 0); // something was created there if (credentialManagerDirectory.exists()) { try { FileUtils.deleteDirectory(credentialManagerDirectory); System.out.println( "Deleting Credential Manager's directory: " + credentialManagerDirectory.getAbsolutePath()); } catch (IOException e) { System.out.println(e.getStackTrace()); } } } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#CredentialManagerImpl()}. * @throws CMException */ @Test public void testCredentialManagerImpl() throws CMException { new CredentialManagerImpl(); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#getUsernameAndPasswordForService(java.net.URI, boolean, java.lang.String)}. * @throws URISyntaxException * @throws CMException */ @Test public void testGetUsernameAndPasswordForServiceURI() throws URISyntaxException, CMException { // The Credential Manage's Keystore is empty so we should not be able to find anything initially assertNull(credentialManager.getUsernameAndPasswordForService(serviceURI, false, "")); credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); UsernamePassword testUsernamePassword = credentialManager.getUsernameAndPasswordForService(serviceURI, false, ""); assertNotNull(testUsernamePassword); assertTrue(Arrays.equals(usernamePassword.getPassword(), testUsernamePassword.getPassword())); assertTrue(usernamePassword.getUsername().equals(testUsernamePassword.getUsername())); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#addUsernameAndPasswordForService(net.sf.taverna.t2.security.credentialmanager.UsernamePassword, java.net.URI)}. * @throws URISyntaxException * @throws CMException */ @Test public void testAddUsernameAndPasswordForService() throws CMException, URISyntaxException { String alias = credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); UsernamePassword testUsernamePassword = credentialManager.getUsernameAndPasswordForService(serviceURI, false, ""); assertNotNull(testUsernamePassword); assertTrue(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.KEYSTORE, alias)); assertTrue(Arrays.equals(usernamePassword.getPassword(), testUsernamePassword.getPassword())); assertTrue(usernamePassword.getUsername().equals(testUsernamePassword.getUsername())); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#hasUsernamePasswordForService(java.net.URI)}. * @throws CMException */ @Test public void testHasUsernamePasswordForService() throws CMException { UsernamePassword testUsernamePassword = credentialManager.getUsernameAndPasswordForService(serviceURI, false, ""); assertNull(testUsernamePassword); String alias = credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); testUsernamePassword = credentialManager.getUsernameAndPasswordForService(serviceURI, false, ""); assertNotNull(testUsernamePassword); assertTrue(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.KEYSTORE, alias)); assertTrue(Arrays.equals(usernamePassword.getPassword(), testUsernamePassword.getPassword())); assertTrue(usernamePassword.getUsername().equals(testUsernamePassword.getUsername())); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#deleteUsernameAndPasswordForService(java.net.URI)}. * @throws URISyntaxException * @throws CMException */ @Test public void testDeleteUsernameAndPasswordForServiceURI() throws URISyntaxException, CMException { // The Credential Manage's Keystore is empty initially so this should // have no effect apart from initializing the Keystore/Truststore credentialManager.deleteUsernameAndPasswordForService(serviceURI); credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); credentialManager.deleteUsernameAndPasswordForService(serviceURI); assertNull(credentialManager.getUsernameAndPasswordForService(serviceURI, false, "")); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#addKeyPair(java.security.Key, java.security.cert.Certificate[])}. * @throws CMException * @throws KeyStoreException * @throws NoSuchAlgorithmException * @throws UnrecoverableKeyException * @throws IOException * @throws FileNotFoundException * @throws CertificateException */ @Test public void testAddKeyPair() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException { String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); assertTrue(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); assertTrue(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.KEYSTORE, alias)); credentialManager.deleteKeyPair(alias); assertFalse(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); assertFalse(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.KEYSTORE, alias)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#hasKeyPair(java.security.Key, java.security.cert.Certificate[])}. * @throws CMException * @throws KeyStoreException * @throws NoSuchAlgorithmException * @throws UnrecoverableKeyException * @throws IOException * @throws FileNotFoundException * @throws CertificateException */ @Test public void testHasKeyPair() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException { assertFalse(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); credentialManager.addKeyPair(privateKey, privateKeyCertChain); assertTrue(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#deleteKeyPair(java.lang.String)}. * @throws CMException * @throws KeyStoreException * @throws NoSuchAlgorithmException * @throws UnrecoverableKeyException * @throws IOException * @throws FileNotFoundException * @throws CertificateException */ @Test public void testDeleteKeyPair() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException { // The Credential Manage's Keystore is empty initially so this should // have no effect apart from initializing the Keystore/Truststore credentialManager.deleteKeyPair("somealias"); String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); credentialManager.deleteKeyPair(alias); assertFalse(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.KEYSTORE, alias)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#deleteKeyPair(Key, Certificate[])}. * @throws CMException */ @Test public void testDeleteKeyPair2() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException { credentialManager.addKeyPair(privateKey, privateKeyCertChain); assertTrue(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); credentialManager.deleteKeyPair(privateKey, privateKeyCertChain); assertFalse(credentialManager.hasKeyPair(privateKey, privateKeyCertChain)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#exportKeyPair(java.lang.String, java.io.File, java.lang.String)}. * @throws CMException * @throws KeyStoreException * @throws NoSuchAlgorithmException * @throws UnrecoverableKeyException */ @Test public void testExportKeyPair() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException { String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); File fileToExportTo = new File(credentialManagerDirectory, "test-export-key.p12"); credentialManager.exportKeyPair(alias, fileToExportTo.toPath(), privateKeyAndPKCS12KeystorePassword); assertTrue(fileToExportTo.exists()); // Load it back from the file we just saved KeyStore ks = credentialManager.loadPKCS12Keystore(fileToExportTo.toPath(), privateKeyAndPKCS12KeystorePassword); Enumeration<String> aliases = ks.aliases(); Key newPrivateKey = null; Certificate[] newPrivateKeyCerts = null; while (aliases.hasMoreElements()) { // The test-private-key-cert.p12 file contains only one private key // and corresponding certificate entry alias = aliases.nextElement(); if (ks.isKeyEntry(alias)) { // is it a (private) key entry? newPrivateKey = ks.getKey(alias, privateKeyAndPKCS12KeystorePassword.toCharArray()); newPrivateKeyCerts = ks.getCertificateChain(alias); break; } } assertNotNull(newPrivateKey); assertNotNull(newPrivateKeyCerts); //assertTrue(Arrays.equals(newPrivateKey.getEncoded(), privateKey.getEncoded())); assertTrue(newPrivateKey.equals(privateKey)); assertTrue(Arrays.equals(newPrivateKeyCerts, privateKeyCertChain)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#getCertificate(java.lang.String, java.lang.String)}. * @throws CMException */ @Test public void testGetCertificate() throws CMException { String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); // Get certificate from the Keystore associated with the private key we just inserted Certificate privateKeyCertificate = credentialManager .getCertificate(CredentialManager.KeystoreType.KEYSTORE, alias); assertNotNull(privateKeyCertificate); assertTrue(privateKeyCertChain[0].equals(privateKeyCertificate)); // We should also have some trusted certificates in the Truststore // Need to get their aliases ArrayList<String> truststoreAliases = credentialManager .getAliases(CredentialManager.KeystoreType.TRUSTSTORE); assertTrue(!truststoreAliases.isEmpty()); // Just get the first one Certificate trustedCertificate = credentialManager.getCertificate(CredentialManager.KeystoreType.TRUSTSTORE, truststoreAliases.get(0)); assertNotNull(trustedCertificate); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#getKeyPairsCertificateChain(java.lang.String)}. * @throws CMException */ @Test public void testGetKeyPairCertificateChain() throws CMException { String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); Certificate[] keyPairCertificateChain = credentialManager.getKeyPairsCertificateChain(alias); assertNotNull(keyPairCertificateChain); assertTrue(Arrays.equals(privateKeyCertChain, keyPairCertificateChain)); } /** * Test method for {@link org.apache.taverna.security.credentialmanager.impl.CredentialManagerImpl#getKeyPairsPrivateKey(java.lang.String)}. * @throws CMException */ @Test public void testGetKeyPairsPrivateKey() throws CMException { String alias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); Key prvKey = credentialManager.getKeyPairsPrivateKey(alias); assertNotNull(prvKey); assertEquals(privateKey, prvKey); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#addTrustedCertificate(java.security.cert.X509Certificate)}. * @throws CMException */ @Test public void testAddTrustedCertificate() throws CMException { String alias = credentialManager.addTrustedCertificate(trustedCertficate); assertTrue(credentialManager.hasTrustedCertificate(trustedCertficate)); assertTrue(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.TRUSTSTORE, alias)); credentialManager.deleteTrustedCertificate(alias); assertFalse(credentialManager.hasTrustedCertificate(trustedCertficate)); assertFalse(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.TRUSTSTORE, alias)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#createTrustedCertificateAlias(java.security.cert.X509Certificate)}. * @throws CMException */ @Test public void testGetX509CertificateAlias() throws CMException { String alias = credentialManager.createTrustedCertificateAlias(trustedCertficate); String alias2 = credentialManager.addTrustedCertificate(trustedCertficate); assertEquals(alias, alias2); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#deleteTrustedCertificate(java.lang.String)}. * @throws CMException */ @Test public void testDeleteTrustedCertificate() throws CMException { // The Credential Manage's Truststore is empty initially so this should // have no effect apart from initializing the Keystore/Truststore credentialManager.deleteTrustedCertificate("somealias"); String alias = credentialManager.addTrustedCertificate(trustedCertficate); assertTrue(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.TRUSTSTORE, alias)); credentialManager.deleteTrustedCertificate(alias); assertFalse(credentialManager.hasTrustedCertificate(trustedCertficate)); assertFalse(credentialManager.hasEntryWithAlias(CredentialManager.KeystoreType.TRUSTSTORE, alias)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#deleteTrustedCertificate(X509Certificate)}. * @throws CMException */ @Test public void testDeleteTrustedCertificate2() throws CMException { credentialManager.addTrustedCertificate(trustedCertficate); assertTrue(credentialManager.hasTrustedCertificate(trustedCertficate)); credentialManager.deleteTrustedCertificate(trustedCertficate); assertFalse(credentialManager.hasTrustedCertificate(trustedCertficate)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#isKeyEntry(java.lang.String)}. * @throws CMException */ @Test public void testIsKeyEntry() throws CMException { // The Credential Manage's Keystore/Truststore is empty initially so this should // have no effect apart from initializing them // This should throw an exception assertFalse(credentialManager.isKeyEntry("somealias")); String aliasPassword = credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); String aliasKeyPair = credentialManager.addKeyPair(privateKey, privateKeyCertChain); String aliasTrustedCert = credentialManager.addTrustedCertificate(trustedCertficate); assertTrue(credentialManager.isKeyEntry(aliasPassword)); // passwords are saves as symmetric key entries assertTrue(credentialManager.isKeyEntry(aliasKeyPair)); assertFalse(credentialManager.isKeyEntry(aliasTrustedCert)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#hasEntryWithAlias(java.lang.String, java.lang.String)}. * @throws CMException */ @Test public void testHasEntryWithAlias() throws CMException { String aliasTrustedCert = credentialManager.createTrustedCertificateAlias(trustedCertficate); assertFalse(credentialManager.hasEntryWithAlias(KeystoreType.TRUSTSTORE, aliasTrustedCert)); String aliasTrustedCert2 = credentialManager.addTrustedCertificate(trustedCertficate); assertTrue(credentialManager.hasEntryWithAlias(KeystoreType.TRUSTSTORE, aliasTrustedCert2)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getAliases(net.sf.taverna.t2.security.credentialmanager.CredentialManager.KeystoreType)}. * @throws CMException */ @Test public void testGetAliases() throws CMException { ArrayList<String> keystoreAliases = credentialManager.getAliases(KeystoreType.KEYSTORE); ArrayList<String> truststoreAliases = credentialManager.getAliases(KeystoreType.TRUSTSTORE); // Initially Keystore/Truststore is empty assertTrue(keystoreAliases.isEmpty()); String aliasPassword = credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); String aliasKeyPair = credentialManager.addKeyPair(privateKey, privateKeyCertChain); String aliasTrustedCert = credentialManager.addTrustedCertificate(trustedCertficate); keystoreAliases = credentialManager.getAliases(KeystoreType.KEYSTORE); truststoreAliases = credentialManager.getAliases(KeystoreType.TRUSTSTORE); assertTrue(keystoreAliases.size() == 2); assertTrue(truststoreAliases.size() >= 1); // we at least have the one we inserted but could be more copied from Java's defauls truststore assertTrue(keystoreAliases.contains(aliasPassword)); assertTrue(keystoreAliases.contains(aliasKeyPair)); assertTrue(truststoreAliases.contains(aliasTrustedCert)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getServiceURIsForAllUsernameAndPasswordPairs()}. * @throws CMException * @throws URISyntaxException */ @Test public void testGetServiceURIsForAllUsernameAndPasswordPairs() throws CMException, URISyntaxException { // Initially empty so this assertTrue(credentialManager.getServiceURIsForAllUsernameAndPasswordPairs().isEmpty()); credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); URI serviceURI2 = new URI("http://someservice2"); UsernamePassword usernamePassword2 = new UsernamePassword("testuser2", "testpasswd2"); credentialManager.addUsernameAndPasswordForService(usernamePassword2, serviceURI2); List<URI> serviceURIs = credentialManager.getServiceURIsForAllUsernameAndPasswordPairs(); assertTrue(credentialManager.getServiceURIsForAllUsernameAndPasswordPairs().size() == 2); assertTrue(serviceURIs.contains(serviceURI)); assertTrue(serviceURIs.contains(serviceURI2)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#loadPKCS12Keystore(java.io.File, java.lang.String)}. * @throws CMException * @throws KeyStoreException * @throws NoSuchAlgorithmException * @throws UnrecoverableKeyException */ @Test public void testLoadPKCS12Keystore() throws CMException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException { KeyStore pkcs12Keystore = credentialManager.loadPKCS12Keystore( new File(privateKeyFileURL.getPath()).toPath(), privateKeyAndPKCS12KeystorePassword); Key privateKey2 = null; Certificate[] privateKeyCertChain2 = null; Enumeration<String> aliases = pkcs12Keystore.aliases(); while (aliases.hasMoreElements()) { // The test-private-key-cert.p12 file contains only one private key // and corresponding certificate entry String alias = aliases.nextElement(); if (pkcs12Keystore.isKeyEntry(alias)) { // is it a (private) key entry? privateKey2 = pkcs12Keystore.getKey(alias, privateKeyAndPKCS12KeystorePassword.toCharArray()); privateKeyCertChain2 = pkcs12Keystore.getCertificateChain(alias); break; } } assertNotNull(privateKey2); assertNotNull(privateKeyCertChain2); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#addObserver(net.sf.taverna.t2.lang.observer.Observer)}. */ @Test public void testAddObserver() { credentialManager.addObserver(keystoreChangedObserver); assertEquals(keystoreChangedObserver, credentialManager.getObservers().get(0)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getObservers()}. */ @Test public void testGetObservers() { // Initially there are no observers assertTrue(credentialManager.getObservers().isEmpty()); credentialManager.addObserver(keystoreChangedObserver); assertEquals(keystoreChangedObserver, credentialManager.getObservers().get(0)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#removeObserver(net.sf.taverna.t2.lang.observer.Observer)}. */ @Test public void testRemoveObserver() { credentialManager.addObserver(keystoreChangedObserver); assertTrue(credentialManager.getObservers().size() == 1); credentialManager.removeObserver(keystoreChangedObserver); assertTrue(credentialManager.getObservers().size() == 0); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#confirmMasterPassword(java.lang.String)}. * @throws CMException */ @Test public void testConfirmMasterPassword() throws CMException { credentialManager.confirmMasterPassword("uber"); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#changeMasterPassword(java.lang.String)}. * @throws CMException */ @Test public void testChangeMasterPassword() throws CMException { // Test the changeMasterPassword() method first to see if // it will initialize Credential Manager properly credentialManager.changeMasterPassword("blah"); credentialManager.confirmMasterPassword("blah"); // Add new stuff - key pair and password entries - under the new master password String keyPairAlias = credentialManager.addKeyPair(privateKey, privateKeyCertChain); credentialManager.addUsernameAndPasswordForService(usernamePassword, serviceURI); // Change the master password again and try to retrieve the private key and password credentialManager.changeMasterPassword("hlab"); assertArrayEquals(credentialManager.getUsernameAndPasswordForService(serviceURI, false, "").getPassword(), usernamePassword.getPassword()); assertEquals(privateKey, credentialManager.getKeyPairsPrivateKey(keyPairAlias)); assertTrue(Arrays.equals(privateKeyCertChain, credentialManager.getKeyPairsCertificateChain(keyPairAlias))); // Load the Credential Manager back from the saved file to see of entries will be picked up properly CredentialManagerImpl credentialManagerNew = null; try { credentialManagerNew = new CredentialManagerImpl(); } catch (CMException e) { System.out.println(e.getStackTrace()); } try { credentialManagerNew.setConfigurationDirectoryPath(credentialManagerDirectory.toPath()); } catch (CMException e) { System.out.println(e.getStackTrace()); } // Create the dummy master password provider masterPasswordProvider = new DummyMasterPasswordProvider(); masterPasswordProvider.setMasterPassword("hlab"); List<MasterPasswordProvider> masterPasswordProviders = new ArrayList<MasterPasswordProvider>(); masterPasswordProviders.add(masterPasswordProvider); credentialManager.setMasterPasswordProviders(masterPasswordProviders); // Set an empty list for service username and password providers credentialManagerNew .setServiceUsernameAndPasswordProviders(new ArrayList<ServiceUsernameAndPasswordProvider>()); credentialManager.setJavaTruststorePasswordProviders(new ArrayList<JavaTruststorePasswordProvider>()); credentialManager.setTrustConfirmationProviders(new ArrayList<TrustConfirmationProvider>()); assertArrayEquals(credentialManager.getUsernameAndPasswordForService(serviceURI, false, "").getPassword(), usernamePassword.getPassword()); assertEquals(privateKey, credentialManager.getKeyPairsPrivateKey(keyPairAlias)); assertTrue(Arrays.equals(privateKeyCertChain, credentialManager.getKeyPairsCertificateChain(keyPairAlias))); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#initializeSSL()}. * @throws CMException */ @Test public void testInitializeSSL() throws CMException { //credentialManager.initializeSSL(); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getTavernaSSLSocketFactory()}. * @throws CMException */ @Test public void testGetTavernaSSLSocketFactory() throws CMException { SSLSocketFactory sslSocketFactory = credentialManager.getTavernaSSLSocketFactory(); assertNotNull(sslSocketFactory); // This should also create Taverna's SSLSocketFactory backed by Credential Manager's Keystore and Truststore // if not already created credentialManager.initializeSSL(); assertEquals(sslSocketFactory, credentialManager.getTavernaSSLSocketFactory()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#setMasterPasswordProviders(java.util.List)}. */ @Test public void testSetMasterPasswordProviders() { List<MasterPasswordProvider> masterPasswordProviders = new ArrayList<MasterPasswordProvider>(); masterPasswordProviders.add(masterPasswordProvider); credentialManager.setMasterPasswordProviders(masterPasswordProviders); assertTrue(credentialManager.getMasterPasswordProviders().contains(masterPasswordProvider)); // Set it to null and see what happens credentialManager.setMasterPasswordProviders(null); assertNull(credentialManager.getMasterPasswordProviders()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getMasterPasswordProviders()}. */ @Test public void testGetMasterPasswordProviders() { assertFalse(credentialManager.getMasterPasswordProviders().isEmpty()); assertTrue(credentialManager.getMasterPasswordProviders().contains(masterPasswordProvider)); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#setJavaTruststorePasswordProviders(java.util.List)}. */ @Test public void testSetJavaTruststorePasswordProviders() { List<JavaTruststorePasswordProvider> javaTruststorePasswordProviders = new ArrayList<JavaTruststorePasswordProvider>(); JavaTruststorePasswordProvider javaTruststorePasswordProvider = new DummyJavaTruststorePasswordProvider(); javaTruststorePasswordProvider.setJavaTruststorePassword("blah"); javaTruststorePasswordProviders.add(javaTruststorePasswordProvider); credentialManager.setJavaTruststorePasswordProviders(javaTruststorePasswordProviders); assertTrue(credentialManager.getJavaTruststorePasswordProviders().contains(javaTruststorePasswordProvider)); // Set it to null and see what happens credentialManager.setJavaTruststorePasswordProviders(null); assertNull(credentialManager.getJavaTruststorePasswordProviders()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getJavaTruststorePasswordProviders()}. */ @Test public void testGetJavaTruststorePasswordProviders() { assertTrue(credentialManager.getJavaTruststorePasswordProviders().isEmpty()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#setServiceUsernameAndPasswordProviders(java.util.List)}. * @throws URISyntaxException */ @Test public void testSetServiceUsernameAndPasswordProviders() throws URISyntaxException { List<ServiceUsernameAndPasswordProvider> serviceUsernameAndPasswordProviders = new ArrayList<ServiceUsernameAndPasswordProvider>(); ServiceUsernameAndPasswordProvider serviceUsernameAndPasswordProvider = new DummyServiceUsernameAndPasswordProvider(); serviceUsernameAndPasswordProvider.setServiceUsernameAndPassword(new URI("http://someservice"), new UsernamePassword("blah", "blah")); serviceUsernameAndPasswordProviders.add(serviceUsernameAndPasswordProvider); credentialManager.setServiceUsernameAndPasswordProviders(serviceUsernameAndPasswordProviders); assertTrue(credentialManager.getServiceUsernameAndPasswordProviders() .contains(serviceUsernameAndPasswordProvider)); // Set it to null and see what happens credentialManager.setServiceUsernameAndPasswordProviders(null); assertNull(credentialManager.getServiceUsernameAndPasswordProviders()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getServiceUsernameAndPasswordProviders()}. */ @Test public void testGetServiceUsernameAndPasswordProviders() { assertTrue(credentialManager.getServiceUsernameAndPasswordProviders().isEmpty()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#setTrustConfirmationProviders(java.util.List)}. * @throws IOException */ @Test public void testSetTrustConfirmationProviders() throws IOException { List<TrustConfirmationProvider> trustConfirmationProviders = new ArrayList<TrustConfirmationProvider>(); TrustConfirmationProvider trustConfirmationProvider = new TrustAlwaysTrustConfirmationProvider(); trustConfirmationProviders.add(trustConfirmationProvider); credentialManager.setTrustConfirmationProviders(trustConfirmationProviders); assertTrue(credentialManager.getTrustConfirmationProviders().contains(trustConfirmationProvider)); // Set it to null and see what happens credentialManager.setTrustConfirmationProviders(null); assertNull(credentialManager.getTrustConfirmationProviders()); } /** * Test method for {@link net.sf.taverna.t2.security.credentialmanager.impl.CredentialManagerImpl#getTrustConfirmationProviders()}. */ @Test public void testGetTrustConfirmationProviders() { assertTrue(credentialManager.getTrustConfirmationProviders().isEmpty()); } }