import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
protected Key engineTranslateKey(
    Key key)
    throws InvalidKeyException
{
    if (key instanceof DHPublicKey)
    {
        return new BCElGamalPublicKey((DHPublicKey)key);
    }
    else if (key instanceof DHPrivateKey)
    {
        return new BCElGamalPrivateKey((DHPrivateKey)key);
    }
    else if (key instanceof ElGamalPublicKey)
    {
        return new BCElGamalPublicKey((ElGamalPublicKey)key);
    }
    else if (key instanceof ElGamalPrivateKey)
    {
        return new BCElGamalPrivateKey((ElGamalPrivateKey)key);
    }

    throw new InvalidKeyException("key type unknown");
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
static public AsymmetricKeyParameter generatePublicKeyParameter(
    PublicKey    key)
    throws InvalidKeyException
{
    if (key instanceof ElGamalPublicKey)
    {
        ElGamalPublicKey    k = (ElGamalPublicKey)key;

        return new ElGamalPublicKeyParameters(k.getY(),
            new ElGamalParameters(k.getParams().getP(), k.getParams().getG()));
    }

    throw new InvalidKeyException("can't identify ElGamal public key.");
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
private void elGamalTest()
    throws IOException, ClassNotFoundException
{
    ElGamalPublicKey pub = (ElGamalPublicKey)readObject(elGamalPub);

    if (!elGamalY.equals(pub.getY()))
    {
        fail("public key y mismatch");
    }
    if (!elGamalG.equals(pub.getParameters().getG()))
    {
        fail("public key g mismatch");
    }
    if (!elGamalP.equals(pub.getParameters().getP()))
    {
        fail("public key p mismatch");
    }
    
    ElGamalPrivateKey priv = (ElGamalPrivateKey)readObject(elGamalPriv);

    if (!elGamalX.equals(priv.getX()))
    {
        fail("private key x mismatch");
    }
    if (!elGamalG.equals(priv.getParameters().getG()))
    {
        fail("private key g mismatch");
    }
    if (!elGamalP.equals(priv.getParameters().getP()))
    {
        fail("private key p mismatch");
    }
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
JCEElGamalPublicKey(
    ElGamalPublicKey    key)
{
    this.y = key.getY();
    this.elSpec = key.getParameters();
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
BCElGamalPublicKey(
    ElGamalPublicKey key)
{
    this.y = key.getY();
    this.elSpec = key.getParameters();
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
protected Key engineTranslateKey(
    Key    key)
    throws InvalidKeyException
{
    if (key instanceof RSAPublicKey)
    {
        return new JCERSAPublicKey((RSAPublicKey)key);
    }
    else if (key instanceof RSAPrivateCrtKey)
    {
        //return new JCERSAPrivateCrtKey((RSAPrivateCrtKey)key);
    }
    else if (key instanceof RSAPrivateKey)
    {
        //return new JCERSAPrivateKey((RSAPrivateKey)key);
    }
    else if (key instanceof DHPublicKey)
    {
        //return new JCEDHPublicKey((DHPublicKey)key);
    }
    else if (key instanceof DHPrivateKey)
    {
        //return new JCEDHPrivateKey((DHPrivateKey)key);
    }
    else if (key instanceof DSAPublicKey)
    {
        //return new JDKDSAPublicKey((DSAPublicKey)key);
    }
    else if (key instanceof DSAPrivateKey)
    {
        //return new JDKDSAPrivateKey((DSAPrivateKey)key);
    }
    else if (key instanceof ElGamalPublicKey)
    {
        //return new JCEElGamalPublicKey((ElGamalPublicKey)key);
    }
    else if (key instanceof ElGamalPrivateKey)
    {
        //return new JCEElGamalPrivateKey((ElGamalPrivateKey)key);
    }

    throw new InvalidKeyException("key type unknown");
}
 

import org.bouncycastle.jce.interfaces.ElGamalPublicKey; //导入依赖的package包/类
protected void engineInit(
    int                     opmode,
    Key                     key,
    AlgorithmParameterSpec  params,
    SecureRandom            random) 
throws InvalidKeyException
{
    CipherParameters        param;

    if (params == null)
    {
        if (key instanceof ElGamalPublicKey)
        {
            param = ElGamalUtil.generatePublicKeyParameter((PublicKey)key);
        }
        else if (key instanceof ElGamalPrivateKey)
        {
            param = ElGamalUtil.generatePrivateKeyParameter((PrivateKey)key);
        }
        else
        {
            throw new InvalidKeyException("unknown key type passed to ElGamal");
        }
    }
    else
    {
        throw new IllegalArgumentException("unknown parameter type.");
    }

    if (random != null)
    {
        param = new ParametersWithRandom(param, random);
    }

    switch (opmode)
    {
    case javax.crypto.Cipher.ENCRYPT_MODE:
    case javax.crypto.Cipher.WRAP_MODE:
        cipher.init(true, param);
        break;
    case javax.crypto.Cipher.DECRYPT_MODE:
    case javax.crypto.Cipher.UNWRAP_MODE:
        cipher.init(false, param);
        break;
    default:
        throw new InvalidParameterException("unknown opmode " + opmode + " passed to ElGamal");
    }
}