gt:     throw new UnsupportedOperationException();
context: /* KeyWrappingAlgorithmAdapter.java -- Base Adapter for Key Wrapping algorithms
     Copyright (C) 2006, 2010  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 = Configuration.DEBUG ?
          Logger.getLogger(KeyWrappingAlgorithmAdapter.class.getName()) : null;
    /** 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
    {
  