| /* KeyWrappingAlgorithmAdapter.java -- Base Adapter for Key Wrapping algorithms |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package gnu.javax.crypto.jce.cipher; |
| |
| import gnu.java.security.Configuration; |
| import gnu.java.security.Registry; |
| import gnu.javax.crypto.jce.spec.BlockCipherParameterSpec; |
| import gnu.javax.crypto.kwa.IKeyWrappingAlgorithm; |
| import gnu.javax.crypto.kwa.KeyUnwrappingException; |
| import gnu.javax.crypto.kwa.KeyWrappingAlgorithmFactory; |
| |
| import java.security.AlgorithmParameters; |
| import java.security.InvalidAlgorithmParameterException; |
| import java.security.InvalidKeyException; |
| import java.security.Key; |
| import java.security.KeyFactory; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.SecureRandom; |
| import java.security.spec.AlgorithmParameterSpec; |
| import java.security.spec.InvalidKeySpecException; |
| import java.security.spec.InvalidParameterSpecException; |
| import java.security.spec.X509EncodedKeySpec; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.logging.Logger; |
| |
| import javax.crypto.BadPaddingException; |
| import javax.crypto.Cipher; |
| import javax.crypto.CipherSpi; |
| import javax.crypto.IllegalBlockSizeException; |
| import javax.crypto.NoSuchPaddingException; |
| import javax.crypto.ShortBufferException; |
| import javax.crypto.spec.IvParameterSpec; |
| import javax.crypto.spec.SecretKeySpec; |
| |
| /** |
| * An abstract base class to facilitate implementations of JCE Adapters for |
| * symmetric key block ciphers capable of providing key-wrapping functionality. |
| */ |
| abstract class KeyWrappingAlgorithmAdapter |
| extends CipherSpi |
| { |
| private static final Logger log = Logger.getLogger(KeyWrappingAlgorithmAdapter.class.getName()); |
| /** JCE canonical name of a null-padder. */ |
| private static final String NO_PADDING = "nopadding"; |
| /** Concrete Key Wrapping Algorithm SPI. */ |
| protected IKeyWrappingAlgorithm kwAlgorithm; |
| /** Size in bytes of the padding block to be provided by external padders. */ |
| protected int kwaBlockSize; |
| /** KEK size in bytes. */ |
| protected int kwaKeySize; |
| /** Name of the supported mode. */ |
| protected String supportedMode; |
| /** Operational mode in which this instance was initialised. */ |
| protected int opmode = -1; |
| /** Initialisation Vector if/when user wants to override default one. */ |
| byte[] iv; |
| |
| /** |
| * Creates a new JCE Adapter for the designated Key Wrapping Algorithm name. |
| * |
| * @param name the canonical name of the key-wrapping algorithm. |
| * @param blockSize the block size in bytes of the underlying symmetric-key |
| * block cipher algorithm. |
| * @param keySize the allowed size in bytes of the KEK bytes to initialise the |
| * underlying symmetric-key block cipher algorithm with. |
| * @param supportedMode canonical name of the block mode the underlying cipher |
| * is supporting. |
| */ |
| protected KeyWrappingAlgorithmAdapter(String name, int blockSize, int keySize, |
| String supportedMode) |
| { |
| super(); |
| |
| this.kwAlgorithm = KeyWrappingAlgorithmFactory.getInstance(name); |
| this.kwaBlockSize = blockSize; |
| this.kwaKeySize = keySize; |
| this.supportedMode = supportedMode; |
| } |
| |
| /** |
| * Wraps the encoded form of a designated {@link Key}. |
| * |
| * @param key the key-material to wrap. |
| * @return the wrapped key. |
| * @throws InvalidKeyException If the key cannot be wrapped. |
| */ |
| protected byte[] engineWrap(Key key) |
| throws InvalidKeyException, IllegalBlockSizeException |
| { |
| byte[] keyMaterial = key.getEncoded(); |
| byte[] result = kwAlgorithm.wrap(keyMaterial, 0, keyMaterial.length); |
| return result; |
| } |
| |
| /** |
| * Unwraps a previously-wrapped key-material. |
| * |
| * @param wrappedKey the wrapped key-material to unwrap. |
| * @param wrappedKeyAlgorithm the canonical name of the algorithm, which the |
| * unwrapped key-material represents. This name is used to |
| * instantiate a concrete instance of a {@link Key} for that |
| * algorithm. For example, if the value of this parameter is |
| * <code>DSS</code> and the type (the next parameter) is |
| * {@link Cipher#PUBLIC_KEY} then an attempt to construct a concrete |
| * instance of a {@link java.security.interfaces.DSAPublicKey}, |
| * using the unwrapped key material, shall be made. |
| * @param wrappedKeyType the type of wrapped key-material. MUST be one of |
| * {@link Cipher#PRIVATE_KEY}, {@link Cipher#PUBLIC_KEY}, or |
| * {@link Cipher#SECRET_KEY}. |
| * @return the unwrapped key-material as an instance of {@link Key} or one of |
| * its subclasses. |
| * @throws InvalidKeyException If the key cannot be unwrapped, or if |
| * <code>wrappedKeyType</code> is an inappropriate type for the |
| * unwrapped key. |
| * @throws NoSuchAlgorithmException If the <code>wrappedKeyAlgorithm</code> |
| * is unknown to every currently installed Security Provider. |
| */ |
| protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, |
| int wrappedKeyType) |
| throws InvalidKeyException, NoSuchAlgorithmException |
| { |
| byte[] keyBytes; |
| try |
| { |
| keyBytes = kwAlgorithm.unwrap(wrappedKey, 0, wrappedKey.length); |
| } |
| catch (KeyUnwrappingException x) |
| { |
| InvalidKeyException y = new InvalidKeyException("engineUnwrap()"); |
| y.initCause(x); |
| throw y; |
| } |
| Key result; |
| switch (wrappedKeyType) |
| { |
| case Cipher.SECRET_KEY: |
| result = new SecretKeySpec(keyBytes, wrappedKeyAlgorithm); |
| break; |
| case Cipher.PRIVATE_KEY: |
| case Cipher.PUBLIC_KEY: |
| X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); |
| KeyFactory keyFactory = KeyFactory.getInstance(wrappedKeyAlgorithm); |
| try |
| { |
| if (wrappedKeyType == Cipher.PRIVATE_KEY) |
| result = keyFactory.generatePrivate(keySpec); |
| else |
| result = keyFactory.generatePublic(keySpec); |
| } |
| catch (InvalidKeySpecException x) |
| { |
| InvalidKeyException y = new InvalidKeyException("engineUnwrap()"); |
| y.initCause(x); |
| throw y; |
| } |
| break; |
| default: |
| IllegalArgumentException x = new IllegalArgumentException("Invalid 'wrappedKeyType': " |
| + wrappedKeyType); |
| InvalidKeyException y = new InvalidKeyException("engineUnwrap()"); |
| y.initCause(x); |
| throw y; |
| } |
| return result; |
| } |
| |
| protected int engineGetBlockSize() |
| { |
| return kwaBlockSize; |
| } |
| |
| protected byte[] engineGetIV() |
| { |
| return iv == null ? null : (byte[]) iv.clone(); |
| } |
| |
| protected int engineGetOutputSize(int inputLength) |
| { |
| switch (opmode) |
| { |
| case Cipher.WRAP_MODE: |
| return getOutputSizeForWrap(inputLength); |
| case Cipher.UNWRAP_MODE: |
| return getOutputSizeForUnwrap(inputLength); |
| default: |
| throw new IllegalStateException(); |
| } |
| } |
| |
| protected AlgorithmParameters engineGetParameters() |
| { |
| BlockCipherParameterSpec spec = new BlockCipherParameterSpec(iv, |
| kwaBlockSize, |
| kwaKeySize); |
| AlgorithmParameters result = null; |
| try |
| { |
| result = AlgorithmParameters.getInstance("BlockCipherParameters"); |
| result.init(spec); |
| } |
| catch (NoSuchAlgorithmException x) |
| { |
| if (Configuration.DEBUG) |
| log.fine("Unable to find BlockCipherParameters. Return null"); |
| } |
| catch (InvalidParameterSpecException x) |
| { |
| if (Configuration.DEBUG) |
| log.fine("Unable to initialise BlockCipherParameters. Return null"); |
| } |
| return result; |
| } |
| |
| protected void engineInit(int opmode, Key key, SecureRandom random) |
| throws InvalidKeyException |
| { |
| checkOpMode(opmode); |
| byte[] kekBytes = checkAndGetKekBytes(key); |
| initAlgorithm(opmode, kekBytes, null, random); |
| } |
| |
| protected void engineInit(int opmode, Key key, AlgorithmParameters params, |
| SecureRandom random) |
| throws InvalidAlgorithmParameterException, InvalidKeyException |
| { |
| AlgorithmParameterSpec spec = null; |
| try |
| { |
| if (params != null) |
| spec = params.getParameterSpec(BlockCipherParameterSpec.class); |
| } |
| catch (InvalidParameterSpecException x) |
| { |
| if (Configuration.DEBUG) |
| log.fine("Unable to translate algorithm parameters into an instance " |
| + "of BlockCipherParameterSpec. Discard"); |
| } |
| engineInit(opmode, key, spec, random); |
| } |
| |
| protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params, |
| SecureRandom random) |
| throws InvalidAlgorithmParameterException, InvalidKeyException |
| { |
| checkOpMode(opmode); |
| byte[] kekBytes = checkAndGetKekBytes(key); |
| byte[] ivBytes = null; |
| if (params instanceof BlockCipherParameterSpec) |
| ivBytes = ((BlockCipherParameterSpec) params).getIV(); |
| else if (params instanceof IvParameterSpec) |
| ivBytes = ((IvParameterSpec) params).getIV(); |
| |
| initAlgorithm(opmode, kekBytes, ivBytes, random); |
| } |
| |
| protected void engineSetMode(String mode) throws NoSuchAlgorithmException |
| { |
| if (! supportedMode.equalsIgnoreCase(mode)) |
| throw new UnsupportedOperationException("Only " + supportedMode |
| + " is supported"); |
| } |
| |
| /** |
| * NoPadding is the only padding algorithm supported by Key Wrapping Algorithm |
| * implementations in RI. |
| */ |
| protected void engineSetPadding(String padding) throws NoSuchPaddingException |
| { |
| if (! NO_PADDING.equalsIgnoreCase(padding)) |
| throw new UnsupportedOperationException("Only NoPadding is supported"); |
| } |
| |
| protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLength) |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| protected int engineUpdate(byte[] input, int inputOffset, int inputLength, |
| byte[] output, int outputOffset) |
| throws ShortBufferException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLength) |
| throws IllegalBlockSizeException, BadPaddingException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| protected int engineDoFinal(byte[] input, int inputOffset, int inputLength, |
| byte[] output, int outputOffset) |
| throws IllegalBlockSizeException, BadPaddingException, ShortBufferException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Return the minimum size in bytes of a place holder large enough to receive |
| * the cipher text resulting from a wrap method with the designated size of |
| * the plain text. |
| * <p> |
| * This default implementation ALWAYS returns the smallest multiple of the |
| * <code>kwaBlockSize</code> --passed to this method through its |
| * constructor-- greater than or equal to the designated |
| * <code>inputLength</code>. |
| * |
| * @param inputLength the size of a plain text. |
| * @return an estimate of the size, in bytes, of the place holder to receive |
| * the resulting bytes of a wrap method. |
| */ |
| protected int getOutputSizeForWrap(int inputLength) |
| { |
| return kwaBlockSize * (inputLength + kwaBlockSize - 1) / kwaBlockSize; |
| } |
| |
| /** |
| * Return the minimum size in bytes of a place holder large enough to receive |
| * the plain text resulting from an unwrap method with the designated size of |
| * the cipher text. |
| * <p> |
| * This default implementation ALWAYS returns the smallest multiple of the |
| * <code>paddingBlockSize</code> --passed to this method through its |
| * constructor-- greater than or equal to the designated |
| * <code>inputLength</code>. |
| * |
| * @param inputLength the size of a cipher text. |
| * @return an estimate of the size, in bytes, of the place holder to receive |
| * the resulting bytes of an uwrap method. |
| */ |
| protected int getOutputSizeForUnwrap(int inputLength) |
| { |
| return kwaBlockSize * (inputLength + kwaBlockSize - 1) / kwaBlockSize; |
| } |
| |
| private void checkOpMode(int opmode) |
| { |
| switch (opmode) |
| { |
| case Cipher.WRAP_MODE: |
| case Cipher.UNWRAP_MODE: |
| return; |
| } |
| throw new IllegalArgumentException("Unsupported operational mode: " + opmode); |
| } |
| |
| /** |
| * Returns the key bytes, iff it was in RAW format. |
| * |
| * @param key the opaque JCE secret key to use as the KEK. |
| * @return the bytes of the encoded form of the designated kek, iff it was in |
| * RAW format. |
| * @throws InvalidKeyException if the designated key is not in the RAW format. |
| */ |
| private byte[] checkAndGetKekBytes(Key key) throws InvalidKeyException |
| { |
| if (! Registry.RAW_ENCODING_SHORT_NAME.equalsIgnoreCase(key.getFormat())) |
| throw new InvalidKeyException("Only RAW key format is supported"); |
| byte[] result = key.getEncoded(); |
| int kekSize = result.length; |
| if (kekSize != kwaKeySize) |
| throw new InvalidKeyException("Invalid key material size. Expected " |
| + kwaKeySize + " but found " + kekSize); |
| return result; |
| } |
| |
| private void initAlgorithm(int opmode, byte[] kek, byte[] ivBytes, |
| SecureRandom rnd) |
| throws InvalidKeyException |
| { |
| this.opmode = opmode; |
| Map attributes = new HashMap(); |
| attributes.put(IKeyWrappingAlgorithm.KEY_ENCRYPTION_KEY_MATERIAL, kek); |
| if (ivBytes != null) |
| { |
| this.iv = (byte[]) ivBytes.clone(); |
| attributes.put(IKeyWrappingAlgorithm.INITIAL_VALUE, this.iv); |
| } |
| else |
| this.iv = null; |
| if (rnd != null) |
| attributes.put(IKeyWrappingAlgorithm.SOURCE_OF_RANDOMNESS, rnd); |
| |
| kwAlgorithm.init(attributes); |
| } |
| } |
