| /* |
| * 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. |
| */ |
| |
| /** |
| * @author Vera Y. Petrashkova |
| * @version $Revision$ |
| */ |
| |
| package org.apache.harmony.crypto.tests.javax.crypto; |
| |
| import java.security.InvalidKeyException; |
| import java.security.Key; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.NoSuchProviderException; |
| import java.security.Provider; |
| import java.security.SecureRandom; |
| import java.security.spec.InvalidKeySpecException; |
| import java.security.spec.KeySpec; |
| |
| import javax.crypto.KeyGenerator; |
| import javax.crypto.SecretKey; |
| import javax.crypto.SecretKeyFactory; |
| import javax.crypto.SecretKeyFactorySpi; |
| import javax.crypto.spec.DESKeySpec; |
| import javax.crypto.spec.DESedeKeySpec; |
| import javax.crypto.spec.SecretKeySpec; |
| |
| import org.apache.harmony.crypto.tests.support.MySecretKeyFactorySpi; |
| import org.apache.harmony.security.tests.support.SpiEngUtils; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Tests for <code>SecretKeyFactory</code> class constructors and methods. |
| * |
| */ |
| public class SecretKeyFactoryTest extends TestCase { |
| |
| public static final String srvSecretKeyFactory = "SecretKeyFactory"; |
| |
| private static String defaultAlgorithm1 = "DESede"; |
| private static String defaultAlgorithm2 = "DES"; |
| |
| public static String defaultAlgorithm = null; |
| |
| private static String defaultProviderName = null; |
| |
| private static Provider defaultProvider = null; |
| |
| private static final String[] invalidValues = SpiEngUtils.invalidValues; |
| |
| public static final String[] validValues = new String[2]; |
| private static boolean DEFSupported = false; |
| |
| private static final String NotSupportMsg = "Default algorithm is not supported"; |
| |
| static { |
| defaultProvider = SpiEngUtils.isSupport(defaultAlgorithm1, |
| srvSecretKeyFactory); |
| DEFSupported = (defaultProvider != null); |
| if (DEFSupported) { |
| defaultAlgorithm = defaultAlgorithm1; |
| validValues[0] = defaultAlgorithm.toUpperCase(); |
| validValues[1] = defaultAlgorithm.toLowerCase(); |
| defaultProviderName = defaultProvider.getName(); |
| } else { |
| defaultProvider = SpiEngUtils.isSupport(defaultAlgorithm2, |
| srvSecretKeyFactory); |
| DEFSupported = (defaultProvider != null); |
| if (DEFSupported) { |
| defaultAlgorithm = defaultAlgorithm2; |
| validValues[0] = defaultAlgorithm.toUpperCase(); |
| validValues[2] = defaultAlgorithm.toLowerCase(); |
| defaultProviderName = defaultProvider.getName(); |
| } else { |
| defaultAlgorithm = null; |
| defaultProviderName = null; |
| defaultProvider = null; |
| } |
| } |
| } |
| |
| protected SecretKeyFactory[] createSKFac() { |
| if (!DEFSupported) { |
| fail(defaultAlgorithm + " algorithm is not supported"); |
| return null; |
| } |
| SecretKeyFactory[] skF = new SecretKeyFactory[3]; |
| try { |
| skF[0] = SecretKeyFactory.getInstance(defaultAlgorithm); |
| skF[1] = SecretKeyFactory.getInstance(defaultAlgorithm, |
| defaultProvider); |
| skF[2] = SecretKeyFactory.getInstance(defaultAlgorithm, |
| defaultProviderName); |
| return skF; |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| /** |
| * Test for <code>SecretKeyFactory</code> constructor |
| * Assertion: returns SecretKeyFactory object |
| */ |
| public void testSecretKeyFactory01() throws NoSuchAlgorithmException, |
| InvalidKeySpecException, InvalidKeyException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| SecretKeyFactorySpi spi = new MySecretKeyFactorySpi(); |
| SecretKeyFactory secKF = new mySecretKeyFactory(spi, defaultProvider, |
| defaultAlgorithm); |
| assertEquals("Incorrect algorithm", secKF.getAlgorithm(), |
| defaultAlgorithm); |
| assertEquals("Incorrect provider", secKF.getProvider(), defaultProvider); |
| assertNull("Incorrect result", secKF.generateSecret(null)); |
| assertNull("Incorrect result", secKF.getKeySpec(null, null)); |
| assertNull("Incorrect result", secKF.translateKey(null)); |
| secKF = new mySecretKeyFactory(null, null, null); |
| assertNull("Algorithm must be null", secKF.getAlgorithm()); |
| assertNull("Provider must be null", secKF.getProvider()); |
| try { |
| secKF.translateKey(null); |
| fail("NullPointerException must be thrown"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm)</code> method |
| * Assertions: |
| * throws NullPointerException when algorithm is null; |
| * throws NoSuchAlgorithmException when algorithm has invalid value |
| */ |
| public void testSecretKeyFactory02() throws NoSuchAlgorithmException { |
| try { |
| SecretKeyFactory.getInstance(null); |
| fail("NullPointerException or NoSuchAlgorithmException should be thrown if algorithm is null"); |
| } catch (NullPointerException e) { |
| } catch (NoSuchAlgorithmException e) { |
| } |
| for (int i = 0; i < invalidValues.length; i++) { |
| try { |
| SecretKeyFactory.getInstance(invalidValues[i]); |
| fail("NoSuchAlgorithmException was not thrown as expected"); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm)</code> method |
| * Assertion: returns SecretKeyObject |
| */ |
| public void testSecretKeyFactory03() throws NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| for (int i = 0; i < validValues.length; i++) { |
| SecretKeyFactory secKF = SecretKeyFactory |
| .getInstance(validValues[i]); |
| assertEquals("Incorrect algorithm", secKF.getAlgorithm(), |
| validValues[i]); |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, String provider)</code> |
| * method |
| * Assertion: |
| * throws NullPointerException when algorithm is null; |
| * throws NoSuchAlgorithmException when algorithm is invalid |
| */ |
| public void testSecretKeyFactory04() throws NoSuchAlgorithmException, |
| NoSuchProviderException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| try { |
| SecretKeyFactory.getInstance(null, defaultProviderName); |
| fail("NullPointerException or NoSuchAlgorithmException should be thrown if algorithm is null"); |
| } catch (NullPointerException e) { |
| } catch (NoSuchAlgorithmException e) { |
| } |
| for (int i = 0; i < invalidValues.length; i++) { |
| try { |
| SecretKeyFactory.getInstance(invalidValues[i], |
| defaultProviderName); |
| fail("NoSuchAlgorithmException was not thrown as expected (algorithm: " |
| .concat(invalidValues[i]).concat(")")); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, String provider)</code> |
| * method |
| * Assertion: |
| * throws IllegalArgumentException when provider is null or empty; |
| * throws NoSuchProviderException when provider has invalid value |
| */ |
| public void testSecretKeyFactory05() throws NoSuchAlgorithmException, |
| NoSuchProviderException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| String prov = null; |
| for (int i = 0; i < validValues.length; i++) { |
| try { |
| SecretKeyFactory.getInstance(validValues[i], prov); |
| fail("IllegalArgumentException was not thrown as expected (algorithm: " |
| .concat(validValues[i]).concat(" provider: null")); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| SecretKeyFactory.getInstance(validValues[i], ""); |
| fail("IllegalArgumentException was not thrown as expected (algorithm: " |
| .concat(validValues[i]).concat(" provider: empty")); |
| } catch (IllegalArgumentException e) { |
| } |
| for (int j = 1; j < invalidValues.length; j++) { |
| try { |
| SecretKeyFactory.getInstance(validValues[i], |
| invalidValues[j]); |
| fail("NoSuchProviderException was not thrown as expected (algorithm: " |
| .concat(validValues[i]).concat(" provider: ") |
| .concat(invalidValues[j]).concat(")")); |
| } catch (NoSuchProviderException e) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, String provider)</code> |
| * method |
| * Assertion: returns SecretKeyFactory object |
| */ |
| public void testSecretKeyFactory06() throws NoSuchProviderException, |
| NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| for (int i = 0; i < validValues.length; i++) { |
| SecretKeyFactory secKF = SecretKeyFactory.getInstance( |
| validValues[i], defaultProviderName); |
| assertEquals("Incorrect algorithm", secKF.getAlgorithm(), |
| validValues[i]); |
| assertEquals("Incorrect provider", secKF.getProvider().getName(), |
| defaultProviderName); |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, Provider provider)</code> |
| * method |
| * Assertion: throws NullPointerException when algorithm is null; |
| * throws NoSuchAlgorithmException when algorithm is invalid |
| */ |
| public void testSecretKeyFactory07() throws NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| try { |
| SecretKeyFactory.getInstance(null, defaultProvider); |
| fail("NullPointerException or NoSuchAlgorithmException should be thrown if algorithm is null"); |
| } catch (NullPointerException e) { |
| } catch (NoSuchAlgorithmException e) { |
| } |
| for (int i = 0; i < invalidValues.length; i++) { |
| try { |
| SecretKeyFactory.getInstance(invalidValues[i], defaultProvider); |
| fail("NoSuchAlgorithmException was not thrown as expected (algorithm: " |
| .concat(invalidValues[i]).concat(")")); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, Provider provider)</code> |
| * method |
| * Assertion: throws IllegalArgumentException when provider is null |
| */ |
| public void testSecretKeyFactory08() throws NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| Provider prov = null; |
| for (int i = 0; i < validValues.length; i++) { |
| try { |
| SecretKeyFactory.getInstance(validValues[i], prov); |
| fail("IllegalArgumentException was not thrown as expected (provider is null, algorithm: " |
| .concat(validValues[i]).concat(")")); |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| } |
| |
| /** |
| * Test for <code>getInstance(String algorithm, Provider provider)</code> |
| * method |
| * Assertion: returns SecretKeyFactory object |
| */ |
| public void testSecretKeyFactory09() throws NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| for (int i = 0; i < validValues.length; i++) { |
| SecretKeyFactory secKF = SecretKeyFactory.getInstance( |
| validValues[i], defaultProvider); |
| assertEquals("Incorrect algorithm", secKF.getAlgorithm(), |
| validValues[i]); |
| assertEquals("Incorrect provider", secKF.getProvider(), |
| defaultProvider); |
| } |
| } |
| |
| /** |
| * Test for <code>generateSecret(KeySpec keySpec)</code> and |
| * <code>getKeySpec(SecretKey key, Class keySpec) |
| * methods |
| * Assertion: |
| * throw InvalidKeySpecException if parameter is inappropriate |
| */ |
| public void testSecretKeyFactory10() throws InvalidKeyException, |
| InvalidKeySpecException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| byte[] bb = new byte[24]; |
| KeySpec ks = (defaultAlgorithm.equals(defaultAlgorithm2) ? (KeySpec)new DESKeySpec(bb) : |
| (KeySpec)new DESedeKeySpec(bb)); |
| KeySpec rks = null; |
| SecretKeySpec secKeySpec = new SecretKeySpec(bb, defaultAlgorithm); |
| SecretKey secKey = null; |
| SecretKeyFactory[] skF = createSKFac(); |
| assertNotNull("SecretKeyFactory object were not created", skF); |
| for (int i = 0; i < skF.length; i++) { |
| try { |
| skF[i].generateSecret(null); |
| fail("generateSecret(null): InvalidKeySpecException must be thrown"); |
| } catch (InvalidKeySpecException e) { |
| } |
| |
| secKey = skF[i].generateSecret(ks); |
| try { |
| skF[i].getKeySpec(null, null); |
| fail("getKeySpec(null,null): InvalidKeySpecException must be thrown"); |
| } catch (InvalidKeySpecException e) { |
| } |
| try { |
| skF[i].getKeySpec(null, ks.getClass()); |
| fail("getKeySpec(null, Class): InvalidKeySpecException must be thrown"); |
| } catch (InvalidKeySpecException e) { |
| } |
| try { |
| skF[i].getKeySpec(secKey, null); |
| fail("getKeySpec(secKey, null): NullPointerException or InvalidKeySpecException must be thrown"); |
| } catch (InvalidKeySpecException e) { |
| // Expected |
| } catch (NullPointerException e) { |
| // Expected |
| } |
| |
| try { |
| Class c; |
| if (defaultAlgorithm.equals(defaultAlgorithm2)) { |
| c = DESedeKeySpec.class; |
| } else { |
| c = DESKeySpec.class; |
| } |
| skF[i].getKeySpec(secKeySpec, c); |
| fail("getKeySpec(secKey, Class): InvalidKeySpecException must be thrown"); |
| } catch (InvalidKeySpecException e) { |
| } |
| rks = skF[i].getKeySpec(secKeySpec, ks.getClass()); |
| if (defaultAlgorithm.equals(defaultAlgorithm1)) { |
| assertTrue("Incorrect getKeySpec() result 1", |
| rks instanceof DESedeKeySpec); |
| } else { |
| assertTrue("Incorrect getKeySpec() result 1", |
| rks instanceof DESKeySpec); |
| } |
| |
| rks = skF[i].getKeySpec(secKey, ks.getClass()); |
| if (defaultAlgorithm.equals(defaultAlgorithm1)) { |
| assertTrue("Incorrect getKeySpec() result 2", |
| rks instanceof DESedeKeySpec); |
| } else { |
| assertTrue("Incorrect getKeySpec() result 2", |
| rks instanceof DESKeySpec); |
| } |
| } |
| } |
| |
| public void test_getAlgorithm() throws NoSuchAlgorithmException { |
| for (int i = 0; i < validValues.length; i++) { |
| SecretKeyFactory secKF = SecretKeyFactory |
| .getInstance(validValues[i]); |
| assertEquals("Incorrect algorithm", secKF.getAlgorithm(), |
| validValues[i]); |
| } |
| |
| Mock_SecretKeyFactory msf = new Mock_SecretKeyFactory(null, null, null); |
| assertNull(msf.getAlgorithm()); |
| } |
| |
| class Mock_SecretKeyFactory extends SecretKeyFactory{ |
| protected Mock_SecretKeyFactory(SecretKeyFactorySpi arg0, Provider arg1, String arg2) { |
| super(arg0, arg1, arg2); |
| } |
| } |
| |
| public void test_getProvider() throws NoSuchAlgorithmException { |
| for (int i = 0; i < validValues.length; i++) { |
| SecretKeyFactory secKF = SecretKeyFactory |
| .getInstance(validValues[i]); |
| assertNotNull(secKF.getProvider()); |
| } |
| |
| Mock_SecretKeyFactory msf = new Mock_SecretKeyFactory(null, null, null); |
| assertNull(msf.getProvider()); |
| } |
| |
| public void test_translateKeyLjavax_crypto_SecretKey() |
| throws NoSuchAlgorithmException, InvalidKeyException { |
| KeyGenerator kg = null; |
| Key key = null; |
| SecretKeyFactory secKF = null; |
| |
| for (int i = 0; i < validValues.length; i++) { |
| secKF = SecretKeyFactory |
| .getInstance(validValues[i]); |
| assertNotNull(secKF.getProvider()); |
| kg = KeyGenerator.getInstance(secKF.getAlgorithm()); |
| kg.init(new SecureRandom()); |
| key = kg.generateKey(); |
| |
| secKF.translateKey((SecretKey) key); |
| } |
| try { |
| secKF.translateKey(null); |
| fail("InvalidKeyException expected"); |
| } catch (InvalidKeyException e) { |
| //expected |
| } |
| } |
| } |
| |
| class mySecretKeyFactory extends SecretKeyFactory { |
| public mySecretKeyFactory(SecretKeyFactorySpi spi, Provider prov, String alg) { |
| super(spi, prov, alg); |
| } |
| } |