package org.bouncycastle.jce.provider;import java.lang.reflect.Constructor;import java.security.InvalidKeyException;import java.security.spec.InvalidKeySpecException;import java.security.spec.KeySpec;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactorySpi;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.DESedeKeySpec;import javax.crypto.spec.PBEKeySpec;import javax.crypto.spec.SecretKeySpec;import org.bouncycastle.asn1.DERObjectIdentifier;import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;import org.bouncycastle.crypto.CipherParameters;import org.bouncycastle.crypto.params.DESParameters;import org.bouncycastle.crypto.params.KeyParameter;import org.bouncycastle.crypto.params.ParametersWithIV;public class JCESecretKeyFactory    extends SecretKeyFactorySpi    implements PBE{    protected String                algName;    protected DERObjectIdentifier   algOid;    protected JCESecretKeyFactory(        String               algName,        DERObjectIdentifier  algOid)    {        this.algName = algName;        this.algOid = algOid;    }    protected SecretKey engineGenerateSecret(        KeySpec keySpec)    throws InvalidKeySpecException    {        if (keySpec instanceof SecretKeySpec)        {            return (SecretKey)keySpec;        }        throw new InvalidKeySpecException("Invalid KeySpec");    }    protected KeySpec engineGetKeySpec(        SecretKey key,        Class keySpec)    throws InvalidKeySpecException    {        if (keySpec == null)        {            throw new InvalidKeySpecException("keySpec parameter is null");        }        if (key == null)        {            throw new InvalidKeySpecException("key parameter is null");        }                if (SecretKeySpec.class.isAssignableFrom(keySpec))        {            return new SecretKeySpec(key.getEncoded(), algName);        }        try        {            Class[] parameters = { byte[].class };            Constructor c = keySpec.getConstructor(parameters);            Object[]    p = new Object[1];            p[0] = key.getEncoded();            return (KeySpec)c.newInstance(p);        }        catch (Exception e)        {            throw new InvalidKeySpecException(e.toString());        }    }    protected SecretKey engineTranslateKey(        SecretKey key)    throws InvalidKeyException    {        if (key == null)        {            throw new InvalidKeyException("key parameter is null");        }                if (!key.getAlgorithm().equalsIgnoreCase(algName))        {            throw new InvalidKeyException("Key not of type " + algName + ".");        }        return new SecretKeySpec(key.getEncoded(), algName);    }    /*     * classes that inherit from us     */        static public class PBEKeyFactory        extends JCESecretKeyFactory    {        private boolean forCipher;        private int     scheme;        private int     digest;        private int     keySize;        private int     ivSize;                public PBEKeyFactory(            String              algorithm,            DERObjectIdentifier oid,            boolean             forCipher,            int                 scheme,            int                 digest,            int                 keySize,            int                 ivSize)        {            super(algorithm, oid);                        this.forCipher = forCipher;            this.scheme = scheme;            this.digest = digest;            this.keySize = keySize;            this.ivSize = ivSize;        }            protected SecretKey engineGenerateSecret(            KeySpec keySpec)            throws InvalidKeySpecException        {            if (keySpec instanceof PBEKeySpec)            {                PBEKeySpec          pbeSpec = (PBEKeySpec)keySpec;                CipherParameters    param;                                if (pbeSpec.getSalt() == null)                {                    return new JCEPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, null);                }                                if (forCipher)                {                    param = Util.makePBEParameters(pbeSpec, scheme, digest, keySize, ivSize);                }                else                {                    param = Util.makePBEMacParameters(pbeSpec, scheme, digest, keySize);                }                                return new JCEPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, param);            }                        throw new InvalidKeySpecException("Invalid KeySpec");        }    }    static public class DESPBEKeyFactory        extends JCESecretKeyFactory    {        private boolean forCipher;        private int     scheme;        private int     digest;        private int     keySize;        private int     ivSize;                public DESPBEKeyFactory(            String              algorithm,            DERObjectIdentifier oid,            boolean             forCipher,            int                 scheme,            int                 digest,            int                 keySize,            int                 ivSize)        {            super(algorithm, oid);                        this.forCipher = forCipher;            this.scheme = scheme;            this.digest = digest;            this.keySize = keySize;            this.ivSize = ivSize;        }            protected SecretKey engineGenerateSecret(            KeySpec keySpec)        throws InvalidKeySpecException        {            if (keySpec instanceof PBEKeySpec)            {                PBEKeySpec pbeSpec = (PBEKeySpec)keySpec;                CipherParameters    param;                                if (pbeSpec.getSalt() == null)                {                    return new JCEPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, null);                }                                if (forCipher)                {                    param = Util.makePBEParameters(pbeSpec, scheme, digest, keySize, ivSize);                }                else                {                    param = Util.makePBEMacParameters(pbeSpec, scheme, digest, keySize);                }                                if (param instanceof ParametersWithIV)                {                    KeyParameter    kParam = (KeyParameter)((ParametersWithIV)param).getParameters();                    DESParameters.setOddParity(kParam.getKey());                }                else                {                    KeyParameter    kParam = (KeyParameter)param;                    DESParameters.setOddParity(kParam.getKey());                }                                return new JCEPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, param);            }                        throw new InvalidKeySpecException("Invalid KeySpec");        }    }        static public class DES        extends JCESecretKeyFactory    {        public DES()        {            super("DES", null);        }        protected SecretKey engineGenerateSecret(            KeySpec keySpec)        throws InvalidKeySpecException        {            if (keySpec instanceof DESKeySpec)            {                DESKeySpec desKeySpec = (DESKeySpec)keySpec;                return new SecretKeySpec(desKeySpec.getKey(), "DES");            }            return super.engineGenerateSecret(keySpec);        }    }    static public class DESede        extends JCESecretKeyFactory    {        public DESede()        {            super("DESede", null);        }        protected KeySpec engineGetKeySpec(            SecretKey key,            Class keySpec)        throws InvalidKeySpecException        {            if (keySpec == null)            {                throw new InvalidKeySpecException("keySpec parameter is null");            }            if (key == null)            {                throw new InvalidKeySpecException("key parameter is null");            }                        if (SecretKeySpec.class.isAssignableFrom(keySpec))            {                return new SecretKeySpec(key.getEncoded(), algName);            }            else if (DESedeKeySpec.class.isAssignableFrom(keySpec))            {                byte[]  bytes = key.getEncoded();                try                {                    if (bytes.length == 16)                    {                        byte[]  longKey = new byte[24];                        System.arraycopy(bytes, 0, longKey, 0, 16);                        System.arraycopy(bytes, 0, longKey, 16, 8);                        return new DESedeKeySpec(longKey);                    }                    else                    {                        return new DESedeKeySpec(bytes);                    }                }                catch (Exception e)                {                    throw new InvalidKeySpecException(e.toString());                }            }