| /* |
| * 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.math.BigInteger; |
| import java.security.InvalidAlgorithmParameterException; |
| import java.security.InvalidParameterException; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.NoSuchProviderException; |
| import java.security.Provider; |
| import java.security.SecureRandom; |
| import java.security.spec.AlgorithmParameterSpec; |
| import java.security.spec.DSAParameterSpec; |
| import java.security.spec.RSAKeyGenParameterSpec; |
| |
| import javax.crypto.Cipher; |
| import javax.crypto.KeyGenerator; |
| import javax.crypto.KeyGeneratorSpi; |
| import javax.crypto.SecretKey; |
| import javax.crypto.spec.IvParameterSpec; |
| |
| import org.apache.harmony.crypto.tests.support.MyKeyGeneratorSpi; |
| import org.apache.harmony.security.tests.support.SpiEngUtils; |
| |
| import junit.framework.TestCase; |
| |
| |
| /** |
| * Tests for KeyGenerator constructor and methods |
| * |
| */ |
| public class KeyGeneratorTest extends TestCase { |
| |
| public static final String srvKeyGenerator = "KeyGenerator"; |
| |
| public static final String validAlgorithmsKeyGenerator [] = |
| {"DESede", "DES", "AES", "HmacMD5"}; |
| |
| private static final int [] validKeySizes = { 168, 56, 256, 56}; |
| |
| private static int defaultKeySize = -1; |
| |
| private static String defaultAlgorithm = null; |
| |
| private static String defaultProviderName = null; |
| |
| private static Provider defaultProvider = null; |
| |
| private static boolean DEFSupported = false; |
| |
| private static final String NotSupportMsg = "There is no suitable provider for KeyGenerator"; |
| |
| private static final String[] invalidValues = SpiEngUtils.invalidValues; |
| |
| private static String[] validValues = new String[3]; |
| |
| static { |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| defaultProvider = SpiEngUtils.isSupport(validAlgorithmsKeyGenerator[i], |
| srvKeyGenerator); |
| DEFSupported = (defaultProvider != null); |
| if (DEFSupported) { |
| defaultAlgorithm = validAlgorithmsKeyGenerator[i]; |
| defaultKeySize = validKeySizes[i]; |
| defaultProviderName = defaultProvider.getName(); |
| validValues[0] = defaultAlgorithm; |
| validValues[1] = defaultAlgorithm.toUpperCase(); |
| validValues[2] = defaultAlgorithm.toLowerCase(); |
| break; |
| } |
| } |
| } |
| |
| private KeyGenerator[] createKGs() throws Exception { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| } |
| |
| KeyGenerator [] kg = new KeyGenerator[3]; |
| kg[0] = KeyGenerator.getInstance(defaultAlgorithm); |
| kg[1] = KeyGenerator.getInstance(defaultAlgorithm, defaultProvider); |
| kg[2] = KeyGenerator.getInstance(defaultAlgorithm, defaultProviderName); |
| return kg; |
| } |
| |
| |
| /** |
| * Test for <code>KeyGenerator</code> constructor Assertion: returns |
| * KeyGenerator object |
| */ |
| public void testKeyGenerator() throws NoSuchAlgorithmException, |
| InvalidAlgorithmParameterException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| KeyGeneratorSpi spi = new MyKeyGeneratorSpi(); |
| KeyGenerator keyG = new myKeyGenerator(spi, defaultProvider, |
| defaultAlgorithm); |
| assertEquals("Incorrect algorithm", keyG.getAlgorithm(), |
| defaultAlgorithm); |
| assertEquals("Incorrect provider", keyG.getProvider(), defaultProvider); |
| AlgorithmParameterSpec params = null; |
| int keysize = 0; |
| try { |
| keyG.init(params, null); |
| fail("InvalidAlgorithmParameterException must be thrown"); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| try { |
| keyG.init(keysize, null); |
| fail("IllegalArgumentException must be thrown"); |
| } catch (IllegalArgumentException e) { |
| } |
| keyG = new myKeyGenerator(null, null, null); |
| assertNull("Algorithm must be null", keyG.getAlgorithm()); |
| assertNull("Provider must be null", keyG.getProvider()); |
| |
| try { |
| keyG.init(params, null); |
| fail("NullPointerException must be thrown"); |
| } catch (NullPointerException e) { |
| } |
| try { |
| keyG.init(keysize, null); |
| fail("NullPointerException or InvalidParameterException must be thrown"); |
| } catch (InvalidParameterException e) { |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm) </code> method Assertions: |
| * throws NullPointerException when algorithm is null throws |
| * NoSuchAlgorithmException when algorithm isnot available |
| */ |
| public void testGetInstanceString01() throws NoSuchAlgorithmException { |
| try { |
| KeyGenerator.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 { |
| KeyGenerator.getInstance(invalidValues[i]); |
| fail("NoSuchAlgorithmException should be thrown"); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm) </code> method |
| * Assertions: returns KeyGenerator object |
| */ |
| public void testGetInstanceString02() throws NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| KeyGenerator keyG; |
| for (int i = 0; i < validValues.length; i++) { |
| keyG = KeyGenerator.getInstance(validValues[i]); |
| assertEquals("Incorrect algorithm", keyG.getAlgorithm(), validValues[i]); |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm, String provider)</code> method |
| * Assertions: |
| * throws NullPointerException when algorithm is null |
| * throws NoSuchAlgorithmException when algorithm isnot available |
| */ |
| public void testGetInstanceStringString01() throws |
| NoSuchAlgorithmException, IllegalArgumentException, |
| NoSuchProviderException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| try { |
| KeyGenerator.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 { |
| KeyGenerator.getInstance(invalidValues[i], defaultProviderName); |
| fail("NoSuchAlgorithmException must be thrown"); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm, String provider)</code> method |
| * Assertions: |
| * throws IllegalArgumentException when provider is null or empty |
| * throws NoSuchProviderException when provider has not be configured |
| */ |
| public void testGetInstanceStringString02() throws IllegalArgumentException, |
| NoSuchAlgorithmException, NoSuchProviderException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| String provider = null; |
| for (int i = 0; i < validValues.length; i++) { |
| try { |
| KeyGenerator.getInstance(validValues[i], provider); |
| fail("IllegalArgumentException must be thrown when provider is null"); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| KeyGenerator.getInstance(validValues[i], ""); |
| fail("IllegalArgumentException must be thrown when provider is empty"); |
| } catch (IllegalArgumentException e) { |
| } |
| for (int j = 1; j < invalidValues.length; j++) { |
| try { |
| KeyGenerator.getInstance(validValues[i], invalidValues[j]); |
| fail("NoSuchProviderException must be thrown (algorithm: " |
| .concat(validValues[i]).concat(" provider: ") |
| .concat(invalidValues[j]).concat(")")); |
| } catch (NoSuchProviderException e) { |
| } |
| } |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm, String provider)</code> method |
| * Assertions: returns KeyGenerator object |
| */ |
| public void testGetInstanceStringString03() throws IllegalArgumentException, |
| NoSuchAlgorithmException, NoSuchProviderException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| KeyGenerator keyG; |
| for (int i = 0; i < validValues.length; i++) { |
| keyG = KeyGenerator.getInstance(validValues[i], defaultProviderName); |
| assertEquals("Incorrect algorithm", keyG.getAlgorithm(), validValues[i]); |
| assertEquals("Incorrect provider", keyG.getProvider().getName(), defaultProviderName); |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm, Provider provider)</code> method |
| * Assertions: |
| * throws NullPointerException when algorithm is null |
| * throws NoSuchAlgorithmException when algorithm isnot available |
| */ |
| public void testGetInstanceStringProvider01() throws NoSuchAlgorithmException, |
| IllegalArgumentException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| try { |
| KeyGenerator.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 { |
| KeyGenerator.getInstance(invalidValues[i], defaultProvider); |
| fail("NoSuchAlgorithmException must be thrown"); |
| } catch (NoSuchAlgorithmException e) { |
| } |
| } |
| } |
| /* |
| * Test for <code> getInstance(String algorithm, Provider provider)</code> method |
| * Assertions: |
| * throws IllegalArgumentException when provider is null |
| */ |
| public void testGetInstanceStringProvider02() throws NoSuchAlgorithmException, |
| IllegalArgumentException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| Provider provider = null; |
| for (int i = 0; i < invalidValues.length; i++) { |
| try { |
| KeyGenerator.getInstance(invalidValues[i], provider); |
| fail("IllegalArgumentException must be thrown"); |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| } |
| |
| /* |
| * Test for <code> getInstance(String algorithm, Provider provider)</code> method |
| * Assertions: returns KeyGenerator object |
| */ |
| public void testGetInstanceStringProvider03() throws IllegalArgumentException, |
| NoSuchAlgorithmException { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| KeyGenerator keyA; |
| for (int i = 0; i < validValues.length; i++) { |
| keyA = KeyGenerator.getInstance(validValues[i], defaultProvider); |
| assertEquals("Incorrect algorithm", keyA.getAlgorithm(), validValues[i]); |
| assertEquals("Incorrect provider", keyA.getProvider(), defaultProvider); |
| } |
| } |
| |
| /* |
| * Test for <code>init(int keysize)</code> and |
| * <code>init(int keysize, SecureRandom random)</code> methods |
| * Assertion: throws InvalidParameterException if keysize is wrong |
| * |
| */ |
| public void testInitKey() throws Exception { |
| byte flag = 0xF; |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| if (defaultAlgorithm |
| .equals(validAlgorithmsKeyGenerator[validAlgorithmsKeyGenerator.length - 1])) { |
| return; |
| } |
| int[] size = { Integer.MIN_VALUE, -1, 0, 112, 168, Integer.MAX_VALUE }; |
| KeyGenerator[] kgs = createKGs(); |
| SecureRandom random = new SecureRandom(); |
| |
| for (int i = 0; i < kgs.length; i++) { |
| for (int j = 0; j < size.length; j++) { |
| try { |
| kgs[i].init(size[j]); |
| flag &= 0xE; |
| } catch (InvalidParameterException ignore) { |
| flag &= 0xD; |
| } |
| |
| try { |
| kgs[i].init(size[j], random); |
| flag &= 0xB; |
| } catch (InvalidParameterException ignore) { |
| flag &= 0x7; |
| } |
| } |
| } |
| assertTrue(flag == 0); |
| } |
| |
| /* |
| * Test for <code>init(AlgorithmParameterSpec params)</code> and |
| * <code>init(AlgorithmParameterSpec params, SecureRandom random)</code> methods |
| * Assertion: throws InvalidAlgorithmParameterException when params is null |
| */ |
| public void testInitParams() throws Exception { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| KeyGenerator [] kgs = createKGs(); |
| AlgorithmParameterSpec aps = null; |
| |
| for (int i = 0; i < kgs.length; i++) { |
| try { |
| kgs[i].init(aps); |
| fail("InvalidAlgorithmParameterException must be thrown"); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| try { |
| kgs[i].init(aps, new SecureRandom()); |
| fail("InvalidAlgorithmParameterException must be thrown"); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| } |
| } |
| |
| /* |
| * Test for <code>generateKey()</code> and |
| * <code>init(SecureRandom random)</code> methods |
| * <code>init(int keysize, SecureRandom random)</code> methods |
| * <code>init(int keysize)</code> methods |
| * <code>init(AlgorithmParameterSpec params, SecureRandom random)</code> methods |
| * <code>init(AlgorithmParameterSpec params)</code> methods |
| * Assertions: |
| * initializes KeyGenerator; |
| * returns SecretKey object |
| * |
| */ |
| public void testGenerateKey() throws Exception { |
| if (!DEFSupported) { |
| fail(NotSupportMsg); |
| return; |
| } |
| SecretKey sKey; |
| String dAl = defaultAlgorithm.toUpperCase(); |
| |
| KeyGenerator[] kgs = createKGs(); |
| |
| for (int i = 0; i < kgs.length; i++) { |
| sKey = kgs[i].generateKey(); |
| assertEquals("Incorrect algorithm", sKey.getAlgorithm() |
| .toUpperCase(), dAl); |
| kgs[i].init(new SecureRandom()); |
| sKey = kgs[i].generateKey(); |
| assertEquals("Incorrect algorithm", sKey.getAlgorithm() |
| .toUpperCase(), dAl); |
| kgs[i].init(defaultKeySize); |
| sKey = kgs[i].generateKey(); |
| assertEquals("Incorrect algorithm", sKey.getAlgorithm() |
| .toUpperCase(), dAl); |
| kgs[i].init(defaultKeySize, new SecureRandom()); |
| sKey = kgs[i].generateKey(); |
| assertEquals("Incorrect algorithm", sKey.getAlgorithm() |
| .toUpperCase(), dAl); |
| } |
| } |
| |
| public void test_getAlgorithm() throws NoSuchAlgorithmException { |
| KeyGenerator kg = null; |
| |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[i]); |
| assertEquals(validAlgorithmsKeyGenerator[i], kg.getAlgorithm()); |
| } |
| |
| kg = new myKeyGenerator(null, null, null); |
| assertNull(kg.getAlgorithm()); |
| } |
| |
| public void test_getProvider () throws NoSuchAlgorithmException { |
| KeyGenerator kg = null; |
| |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[i]); |
| assertNotNull(kg.getProvider()); |
| } |
| |
| kg = new myKeyGenerator(null, null, null); |
| assertNull(kg.getProvider()); |
| } |
| |
| public void test_initILjava_security_SecureRandom() throws NoSuchAlgorithmException { |
| SecureRandom random = null; |
| KeyGenerator kg = null; |
| |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[i]); |
| random = new SecureRandom(); |
| kg.init(validKeySizes[i], random); |
| assertNotNull(kg.getProvider()); |
| } |
| |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[0]); |
| |
| try { |
| kg.init(5, random); |
| fail("InvalidParameterException expected"); |
| } catch (InvalidParameterException e) { |
| //expected |
| } |
| } |
| |
| public void test_Ljava_security_SecureRandom() throws NoSuchAlgorithmException { |
| SecureRandom random = null; |
| KeyGenerator kg = null; |
| |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[i]); |
| random = new SecureRandom(); |
| kg.init(random); |
| assertNotNull(kg.getProvider()); |
| } |
| } |
| |
| public void test_initLjava_security_spec_AlgorithmParameterSpec () |
| throws Exception { |
| KeyGenerator kg = null; |
| |
| IvParameterSpec aps = null; |
| SecureRandom sr = new SecureRandom(); |
| |
| byte[] iv = null; |
| iv = new byte[8]; |
| sr.nextBytes(iv); |
| aps = new IvParameterSpec(iv); |
| |
| for (int i = 0; i < validAlgorithmsKeyGenerator.length; i++) { |
| kg = KeyGenerator.getInstance(validAlgorithmsKeyGenerator[i]); |
| try { |
| kg.init(aps); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| assertNotNull(kg.getProvider()); |
| } |
| } |
| } |
| |
| /** |
| * Additional class for KeyGenerator constructor verification |
| */ |
| class myKeyGenerator extends KeyGenerator { |
| |
| public myKeyGenerator(KeyGeneratorSpi keyAgreeSpi, Provider provider, |
| String algorithm) { |
| super(keyAgreeSpi, provider, algorithm); |
| } |
| } |