package au.net.aba.crypto.provider;

/*
 * $Id: TwofishKeyFactory.java,v 1.7 1999/02/18 06:28:51 leachbj Exp $
 * $Author: leachbj $
 *
 * Copyright (C) 1996-1998 Australian Business Access Pty Ltd.
 * All rights reserved.         
 *       
 * Use, modification, copying and distribution of this software is subject the
 * terms and conditions of the ABA Public Licence. See the file
 * "PUBLIC_LICENCE" for additional information.
 *
 * If you have not received a copy of the Public Licence, you must destroy all
 * copies of this file immediately. 
 *
 * $Source: /aba/CVSROOT/jdk1.1/src/au.net.aba/crypto/provider/TwofishKeyFactory.java,v $
 * $Revision: 1.7 $
 * $Date: 1999/02/18 06:28:51 $
 * $State: Exp $
 */

import au.net.aba.crypto.spec.TwofishKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.InvalidKeyException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactorySpi;
import javax.crypto.spec.SecretKeySpec;

/**
 * This class is used to convert Twofish keys into a format usable by the
 * usable by the ABA provider.  The supported KeySpec classes are
 * TwofishKeySpec and SecretKeySpec.  In the case of the SecretKeySpec
 * the key data must not be encoded.  The supported Key class is
 * TwofishKey.
 * <p>
 * This class should not be instantiated directly, instead use the
 * java.security.KeyFactory interface.
 *
 * @see java.security.KeyFactory
 */
public class TwofishKeyFactory extends SecretKeyFactorySpi
{
	public final static String ident = "$Id: TwofishKeyFactory.java,v 1.7 1999/02/18 06:28:51 leachbj Exp $";

	/**
	 * Generates a Twofish SecretKey object from the provided key
	 * specification (key material).  This class supports the
	 * TwofishKeySpec and SecretKeySpec KeySpec classes.
	 *
	 * @returns The secret key.
	 * @exception InvalidKeySpecException  The provided KeySpec was not
	 * 	a TwofishKeySpec or SecretKeySpec instance.
	 */
	protected SecretKey engineGenerateSecret(
		KeySpec keySpec)
		throws InvalidKeySpecException
	{
		if (keySpec instanceof TwofishKeySpec)
		{
			TwofishKeySpec twofishKspec = (TwofishKeySpec)keySpec;

			return new TwofishKey(twofishKspec.getKey());
		}
		else if (keySpec instanceof SecretKeySpec)
		{
			SecretKeySpec skspec = (SecretKeySpec)keySpec;

			if (!"Twofish".equals(skspec.getAlgorithm()))
			{
				throw new InvalidKeySpecException(
					"SecretKeySpec not for Twofish");
			}
			if (!"RAW".equals(skspec.getFormat()))
			{
				throw new InvalidKeySpecException(
					"Unknown format in KeySpec");
			}

			return new TwofishKey(skspec.getEncoded());
		}

		throw new InvalidKeySpecException("Invalid KeySpec");
	}
	/**
	 * Returns a specification (key material) of the given key object.
	 * keySpec identifies the specification class in which the key material
	 * should be returned. It could, for example, be RSAPublicKeySpec.class,
	 * to indicate that the key material should be returned in an instance
	 * of the RSAPublicKeySpec class.
	 * <p>
	 * Can convert from an ABA TwofishKey into a SecretKeySpec or
	 * TwofishKeySpec class.
	 *
	 * @param key	the key the key material is to be recovered from.
	 * @param spec	the class the new key spec object is meant to be from.
	 * @return the new key spec object representing the key material in key.
	 * @exception InvalidKeySpecException	 if the requested key
	 * 	specification is inappropriate for the given key, or the given key
	 * 	cannot be dealt with (e.g., the given key has an unrecognized
	 * 	format).
	 */
	protected KeySpec engineGetKeySpec(
		SecretKey key,
		Class keySpec)
		throws InvalidKeySpecException
	{
		if (key instanceof TwofishKey)
		{
			if (SecretKeySpec.class.isAssignableFrom(keySpec))
			{
				return new SecretKeySpec(key.getEncoded(),
					"Twofish");
			}
			else if (TwofishKeySpec.class.isAssignableFrom(keySpec))
			{
				try
				{
					return new TwofishKeySpec(key.getEncoded());
				}
				catch (InvalidKeyException e)
				{
					throw new InvalidKeySpecException(
						e.getMessage());
				}
			}
		}

		throw new InvalidKeySpecException("not implemented");
	}
	/**
	 * Translates an Twofish key object, whose provider may be unknown or
	 * potentially untrusted, into a corresponding key object of this key
	 * factory. 
	 *
	 * @param key - the key whose provider is unknown or untrusted 
	 * @returns the translated key 
	 * @exception InvalidKeyException if the given key cannot be processed
	 * 	by this key factory. 
	 */
	protected SecretKey engineTranslateKey(
		SecretKey key)
		throws InvalidKeyException
	{
		if (!key.getAlgorithm().equals("Twofish"))
		{
			throw new InvalidKeyException("not a Twofish key");
		}
		
		return new TwofishKey(key.getEncoded());
	}
}