import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
 *  Encryption equivalent to the Crypto++ default ECIES<ECP> settings:
 *
 *  DL_KeyAgreementAlgorithm:        DL_KeyAgreementAlgorithm_DH<struct ECPPoint,struct EnumToType<enum CofactorMultiplicationOption,0> >
 *  DL_KeyDerivationAlgorithm:       DL_KeyDerivationAlgorithm_P1363<struct ECPPoint,0,class P1363_KDF2<class SHA1> >
 *  DL_SymmetricEncryptionAlgorithm: DL_EncryptionAlgorithm_Xor<class HMAC<class SHA1>,0>
 *  DL_PrivateKey:                   DL_Key<ECPPoint>
 *  DL_PrivateKey_EC<class ECP>
 *
 *  Used for Whisper V3
 */
public static byte[] encryptSimple(ECPoint pub, byte[] plaintext) throws IOException, InvalidCipherTextException {
    EthereumIESEngine iesEngine = new EthereumIESEngine(
            new ECDHBasicAgreement(),
            new MGF1BytesGeneratorExt(new SHA1Digest(), 1),
            new HMac(new SHA1Digest()),
            new SHA1Digest(),
            null);

    IESParameters p = new IESParameters(null, null, KEY_SIZE);
    ParametersWithIV parametersWithIV = new ParametersWithIV(p, new byte[0]);

    iesEngine.setHashMacKey(false);

    ECKeyPairGenerator eGen = new ECKeyPairGenerator();
    SecureRandom random = new SecureRandom();
    KeyGenerationParameters gParam = new ECKeyGenerationParameters(CURVE, random);
    eGen.init(gParam);

    EphemeralKeyPairGenerator ephemeralKeyPairGenerator =
            new EphemeralKeyPairGenerator(/*testGen*/eGen, new ECIESPublicKeyEncoder());

    iesEngine.init(new ECPublicKeyParameters(pub, CURVE), parametersWithIV, ephemeralKeyPairGenerator);

    return iesEngine.processBlock(plaintext, 0, plaintext.length);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
 * Initialise the encryptor.
 *
 * @param publicKey      the recipient's/sender's public key parameters
 * @param params         encoding and derivation parameters, may be wrapped to include an IV for an underlying block cipher.
 * @param ephemeralKeyPairGenerator             the ephemeral key pair generator to use.
 */
public void init(AsymmetricKeyParameter publicKey, CipherParameters params, EphemeralKeyPairGenerator ephemeralKeyPairGenerator)
{
    this.forEncryption = true;
    this.pubParam = publicKey;
    this.keyPairGenerator = ephemeralKeyPairGenerator;

    extractParams(params);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
     *  Encryption equivalent to the Crypto++ default ECIES<ECP> settings:
     *
     *  DL_KeyAgreementAlgorithm:        DL_KeyAgreementAlgorithm_DH<struct ECPPoint,struct EnumToType<enum CofactorMultiplicationOption,0> >
     *  DL_KeyDerivationAlgorithm:       DL_KeyDerivationAlgorithm_P1363<struct ECPPoint,0,class P1363_KDF2<class SHA1> >
     *  DL_SymmetricEncryptionAlgorithm: DL_EncryptionAlgorithm_Xor<class HMAC<class SHA1>,0>
     *  DL_PrivateKey:                   DL_Key<ECPPoint>
     *  DL_PrivateKey_EC<class ECP>
     *
     *  Used for Whisper V3
     */
    public static byte[] encryptSimple(ECPoint pub, byte[] plaintext) throws IOException, InvalidCipherTextException {
        EthereumIESEngine iesEngine = new EthereumIESEngine(
                new ECDHBasicAgreement(),
                new MGF1BytesGeneratorExt(new SHA1Digest(), 1),
                new HMac(new SHA1Digest()),
                new SHA1Digest(),
                null);

        IESParameters p = new IESParameters(null, null, KEY_SIZE);
        ParametersWithIV parametersWithIV = new ParametersWithIV(p, new byte[0]);

        iesEngine.setHashMacKey(false);

        ECKeyPairGenerator eGen = new ECKeyPairGenerator();
        SecureRandom random = new SecureRandom();
        KeyGenerationParameters gParam = new ECKeyGenerationParameters(CURVE, random);
        eGen.init(gParam);

//        AsymmetricCipherKeyPairGenerator testGen = new AsymmetricCipherKeyPairGenerator() {
//            ECKey priv = ECKey.fromPrivate(Hex.decode("d0b043b4c5d657670778242d82d68a29d25d7d711127d17b8e299f156dad361a"));
//
//            @Override
//            public void init(KeyGenerationParameters keyGenerationParameters) {
//            }
//
//            @Override
//            public AsymmetricCipherKeyPair generateKeyPair() {
//                return new AsymmetricCipherKeyPair(new ECPublicKeyParameters(priv.getPubKeyPoint(), CURVE),
//                        new ECPrivateKeyParameters(priv.getPrivKey(), CURVE));
//            }
//        };

        EphemeralKeyPairGenerator ephemeralKeyPairGenerator =
                new EphemeralKeyPairGenerator(/*testGen*/eGen, new ECIESPublicKeyEncoder());

        iesEngine.init(new ECPublicKeyParameters(pub, CURVE), parametersWithIV, ephemeralKeyPairGenerator);

        return iesEngine.processBlock(plaintext, 0, plaintext.length);
    }
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
MessageEncrypter(SecureRandom random) {
	generator = new ECKeyPairGenerator();
	generator.init(new ECKeyGenerationParameters(PARAMETERS, random));
	parser = new Sec1KeyParser(PARAMETERS, MESSAGE_KEY_BITS);
	KeyEncoder encoder = new PublicKeyEncoder();
	ephemeralGenerator = new EphemeralKeyPairGenerator(generator, encoder);
	ephemeralParser = new PublicKeyParser(PARAMETERS);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
 * Initialise the encryptor.
 *
 * @param publicKey      the recipient's/sender's public key parameters
 * @param params         encoding and derivation parameters, may be wrapped to include an iv for an underlying block cipher.
 * @param ephemeralKeyPairGenerator             the ephemeral key pair generator to use.
 */
public void init(AsymmetricKeyParameter publicKey, CipherParameters params, EphemeralKeyPairGenerator ephemeralKeyPairGenerator)
{
    this.forEncryption = true;
    this.pubParam = publicKey;
    this.keyPairGenerator = ephemeralKeyPairGenerator;

    extractParams(params);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
 * Initialise the encryptor.
 *
 * @param publicKey                 the recipient's/sender's public key parameters
 * @param params                    encoding and derivation parameters, may be wrapped to include an IV for an
 *                                  underlying block cipher.
 * @param ephemeralKeyPairGenerator the ephemeral key pair generator to use.
 */
public void init(AsymmetricKeyParameter publicKey, CipherParameters params,
                 EphemeralKeyPairGenerator ephemeralKeyPairGenerator) {
    this.forEncryption = true;
    this.pubParam = publicKey;
    this.keyPairGenerator = ephemeralKeyPairGenerator;

    extractParams(params);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
/**
 * Initialise the encryptor.
 *
 * @param publicKey
 *            the recipient's/sender's public key parameters
 * @param params
 *            encoding and derivation parameters, may be wrapped to include an IV for an
 *            underlying block cipher.
 * @param ephemeralKeyPairGenerator
 *            the ephemeral key pair generator to use.
 */
public void init(AsymmetricKeyParameter publicKey, CipherParameters params,
        EphemeralKeyPairGenerator ephemeralKeyPairGenerator) {
    this.forEncryption = true;
    this.pubParam = publicKey;
    this.keyPairGenerator = ephemeralKeyPairGenerator;

    extractParams(params);
}
 

import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator; //导入依赖的package包/类
@Test  // ECIES_AES128_SHA256 + Ephemeral Key + IV(all zeroes)
public void test15() throws Throwable{


    byte[] privKey = Hex.decode("a4627abc2a3c25315bff732cb22bc128f203912dd2a840f31e66efb27a47d2b1");

    ECKey ecKey = ECKey.fromPrivate(privKey);

    ECPrivateKeyParameters ecPrivKey = new ECPrivateKeyParameters(ecKey.getPrivKey(), ECKey.CURVE);
    ECPublicKeyParameters  ecPubKey  = new ECPublicKeyParameters(ecKey.getPubKeyPoint(), ECKey.CURVE);

    AsymmetricCipherKeyPair myKey = new AsymmetricCipherKeyPair(ecPubKey, ecPrivKey);


    AESFastEngine aesFastEngine = new AESFastEngine();

    IESEngine iesEngine = new IESEngine(
            new ECDHBasicAgreement(),
            new KDF2BytesGenerator(new SHA256Digest()),
            new HMac(new SHA256Digest()),
            new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));


    byte[]         d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
    byte[]         e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 };

    IESParameters p = new IESWithCipherParameters(d, e, 64, 128);
    ParametersWithIV parametersWithIV = new ParametersWithIV(p, new byte[16]);

    ECKeyPairGenerator eGen = new ECKeyPairGenerator();
    KeyGenerationParameters gParam = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());

    eGen.init(gParam);

    ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
    ECKeyPairGenerator generator = new ECKeyPairGenerator();
    generator.init(keygenParams);

    EphemeralKeyPairGenerator kGen = new EphemeralKeyPairGenerator(generator, new KeyEncoder()
    {
        public byte[] getEncoded(AsymmetricKeyParameter keyParameter)
        {
            return ((ECPublicKeyParameters)keyParameter).getQ().getEncoded();
        }
    });


    ECKeyPairGenerator gen = new ECKeyPairGenerator();
    gen.init(new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom()));

    iesEngine.init(myKey.getPublic(), parametersWithIV, kGen);

    byte[] message = Hex.decode("010101");
    log.info("payload: {}", Hex.toHexString(message));


    byte[] cipher = iesEngine.processBlock(message, 0, message.length);
    log.info("cipher: {}", Hex.toHexString(cipher));


    IESEngine decryptorIES_Engine = new IESEngine(
            new ECDHBasicAgreement(),
            new KDF2BytesGenerator (new SHA256Digest()),
            new HMac(new SHA256Digest()),
            new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));

    decryptorIES_Engine.init(myKey.getPrivate(), parametersWithIV, new ECIESPublicKeyParser(ECKey.CURVE));

    byte[] orig = decryptorIES_Engine.processBlock(cipher, 0, cipher.length);

    log.info("orig: " + Hex.toHexString(orig));
}