How to use org.spongycastle.crypto

public MGF1BytesGeneratorExt(Digest digest, int counterStart) {
  this.digest = digest;
  this.hLen = digest.getDigestSize();
  this.counterStart = counterStart;
}

/**
 * set up for use with stream mode, where the key derivation function
 * is used to provide a stream of bytes to xor with the message.
 *  @param agree the key agreement used as the basis for the encryption
 * @param kdf    the key derivation function used for byte generation
 * @param mac    the message authentication code generator for the message
 * @param hash   hash ing function
 * @param cipher the actual cipher
 */
public EthereumIESEngine(
    BasicAgreement agree,
    DerivationFunction kdf,
    Mac mac, Digest hash, BufferedBlockCipher cipher)
{
  this.agree = agree;
  this.kdf = kdf;
  this.mac = mac;
  this.hash = hash;
  this.macBuf = new byte[mac.getMacSize()];
  this.cipher = cipher;
}

public FrameCodec(EncryptionHandshake.Secrets secrets) {
  this.mac = secrets.mac;
  BlockCipher cipher;
  enc = new SICBlockCipher(cipher = new AESEngine());
  enc.init(true, new ParametersWithIV(new KeyParameter(secrets.aes), new byte[cipher.getBlockSize()]));
  dec = new SICBlockCipher(cipher = new AESEngine());
  dec.init(false, new ParametersWithIV(new KeyParameter(secrets.aes), new byte[cipher.getBlockSize()]));
  egressMac = secrets.egressMac;
  ingressMac = secrets.ingressMac;
}

if (inLen <= (param.getMacKeySize() / 8))
  throw new InvalidCipherTextException("Length of input must be greater than the MAC");
  K1 = new byte[inLen - V.length - mac.getMacSize()];
  K2 = new byte[param.getMacKeySize() / 8];
  K = new byte[K1.length + K2.length];
  kdf.generateBytes(K, 0, K.length);
  K1 = new byte[((IESWithCipherParameters)param).getCipherKeySize() / 8];
  K2 = new byte[param.getMacKeySize() / 8];
  K = new byte[K1.length + K2.length];
  kdf.generateBytes(K, 0, K.length);
  System.arraycopy(K, 0, K1, 0, K1.length);
  System.arraycopy(K, K1.length, K2, 0, K2.length);
    cipher.init(false, new ParametersWithIV(new KeyParameter(K1), IV));
    cipher.init(false, new KeyParameter(K1));
  M = new byte[cipher.getOutputSize(inLen - V.length - mac.getMacSize())];
  len = cipher.processBytes(in_enc, inOff + V.length, inLen - V.length - mac.getMacSize(), M, 0);
  len += cipher.doFinal(M, len);
byte[] P2 = param.getEncodingV();
byte[] T1 = Arrays.copyOfRange(in_enc, end - mac.getMacSize(), end);

ECPrivateKeyParameters ecPrivKey = new ECPrivateKeyParameters(ecKey.getPrivKey(), ECKey.CURVE);
ECPublicKeyParameters  ecPubKey  = new ECPublicKeyParameters(ecKey.getPubKeyPoint(), ECKey.CURVE);
AsymmetricCipherKeyPair myKey = new AsymmetricCipherKeyPair(ecPubKey, ecPrivKey);
AESEngine aesFastEngine = new AESEngine();
IESEngine iesEngine = new IESEngine(
    new ECDHBasicAgreement(),
    new KDF2BytesGenerator(new SHA256Digest()),
    new HMac(new SHA256Digest()),
    new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
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()
ECKeyPairGenerator gen = new ECKeyPairGenerator();
gen.init(new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom()));

private static EthereumIESEngine makeIESEngine(boolean isEncrypt, ECPoint pub, BigInteger prv, byte[] IV) {
  AESEngine aesFastEngine = new AESEngine();
  EthereumIESEngine iesEngine = new EthereumIESEngine(
      new ECDHBasicAgreement(),
      new ConcatKDFBytesGenerator(new SHA256Digest()),
      new HMac(new SHA256Digest()),
      new SHA256Digest(),
      new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
  byte[]         d = new byte[] {};
  byte[]         e = new byte[] {};
  IESParameters p = new IESWithCipherParameters(d, e, KEY_SIZE, KEY_SIZE);
  ParametersWithIV parametersWithIV = new ParametersWithIV(p, IV);
  iesEngine.init(isEncrypt, new ECPrivateKeyParameters(prv, CURVE), new ECPublicKeyParameters(pub, CURVE), parametersWithIV);
  return iesEngine;
}

AESEngine aesFastEngine = new AESEngine();
IESEngine iesEngine = new IESEngine(
    new ECDHBasicAgreement(),
    new KDF2BytesGenerator(new SHA256Digest()),
    new HMac(new SHA256Digest()),
    new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
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);
AsymmetricCipherKeyPair p1 = eGen.generateKeyPair();
AsymmetricCipherKeyPair p2 = eGen.generateKeyPair();
ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
ECKeyPairGenerator generator = new ECKeyPairGenerator();
generator.init(keygenParams);
ECKeyPairGenerator gen = new ECKeyPairGenerator();
gen.init(new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom()));
iesEngine.init(true, p1.getPrivate(), p2.getPublic(), parametersWithIV);
byte[] cipher = iesEngine.processBlock(message, 0, message.length);

public static byte[] encrypt(ECPoint toPub, byte[] plaintext, byte[] macData) {
  ECKeyPairGenerator eGen = new ECKeyPairGenerator();
  SecureRandom random = new SecureRandom();
  KeyGenerationParameters gParam = new ECKeyGenerationParameters(CURVE, random);
  eGen.init(gParam);
  byte[] IV = new byte[KEY_SIZE/8];
  new SecureRandom().nextBytes(IV);
  AsymmetricCipherKeyPair ephemPair = eGen.generateKeyPair();
  BigInteger prv = ((ECPrivateKeyParameters)ephemPair.getPrivate()).getD();
  ECPoint pub = ((ECPublicKeyParameters)ephemPair.getPublic()).getQ();
  EthereumIESEngine iesEngine = makeIESEngine(true, toPub, prv, IV);
  ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(CURVE, random);
  ECKeyPairGenerator generator = new ECKeyPairGenerator();
  generator.init(keygenParams);
  ECKeyPairGenerator gen = new ECKeyPairGenerator();
  gen.init(new ECKeyGenerationParameters(ECKey.CURVE, random));
  byte[] cipher;
  try {
    cipher = iesEngine.processBlock(plaintext, 0, plaintext.length, macData);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    bos.write(pub.getEncoded(false));
    bos.write(IV);
    bos.write(cipher);
    return bos.toByteArray();
  } catch (InvalidCipherTextException e) {
    throw Throwables.propagate(e);
  } catch (IOException e) {
    throw Throwables.propagate(e);
  }
}

    EphemeralKeyPair ephKeyPair = keyPairGenerator.generate();
    this.privParam = ephKeyPair.getKeyPair().getPrivate();
    this.V = ephKeyPair.getEncodedPublicKey();
      this.pubParam = keyParser.readKey(bIn);
      throw new InvalidCipherTextException("unable to recover ephemeral public key: " + e.getMessage(), e);
agree.init(privParam);
BigInteger z = agree.calculateAgreement(pubParam);
byte[] Z = BigIntegers.asUnsignedByteArray(agree.getFieldSize(), z);
  kdfParam = new MGFParameters(VZ);
} else {
  kdfParam = new KDFParameters(VZ, param.getDerivationV());
kdf.init(kdfParam);

/**
 * @param data
 *            - message to hash
 * @return - reipmd160 hash of the message
 */
public static byte[] ripemd160(byte[] data) {
  Digest digest = new RIPEMD160Digest();
  if (data != null) {
    byte[] resBuf = new byte[digest.getDigestSize()];
    digest.update(data, 0, data.length);
    digest.doFinal(resBuf, 0);
    return resBuf;
  }
  throw new NullPointerException("Can't hash a NULL value");
}

public int generateBytes(byte[] out, int outOff, int len) throws DataLengthException, IllegalArgumentException {
  if(out.length - len < outOff) {
    throw new DataLengthException("output buffer too small");
  } else {
    byte[] hashBuf = new byte[this.hLen];
    int counter = 0;
    int hashCounter = counterStart;
    this.digest.reset();
    if(len > this.hLen) {
      do {
        this.ItoOSP(hashCounter++, C);
        this.digest.update(this.seed, 0, this.seed.length);
        this.digest.update(C, 0, C.length);
        this.digest.doFinal(hashBuf, 0);
        System.arraycopy(hashBuf, 0, out, outOff + counter * this.hLen, this.hLen);
        ++counter;
      this.digest.update(this.seed, 0, this.seed.length);
      this.digest.update(C, 0, C.length);
      this.digest.doFinal(hashBuf, 0);
      System.arraycopy(hashBuf, 0, out, outOff + counter * this.hLen, len - counter * this.hLen);

BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(
    new CBCBlockCipher(new AESEngine()), padding);
cipher.reset();
cipher.init(false, params);
byte[] buf = new byte[cipher.getOutputSize(encData.length)];
int len = cipher.processBytes(encData, 0, encData.length, buf, 0);
len += cipher.doFinal(buf, len);

  public byte[] getEncodedPublicKey()
  {
    return publicKeyEncoder.getEncoded(keyPair.getPublic());
  }
}

System.arraycopy(headerData, 0, headBuffer, 3, headerData.length);
enc.processBytes(headBuffer, 0, 16, headBuffer, 0);
enc.processBytes(ptype, 0, ptype.length, buff, 0);
out.write(buff, 0, ptype.length);
egressMac.update(buff, 0, ptype.length);
while (true) {
  int n = frame.payload.read(buff);
  if (n <= 0) break;
  enc.processBytes(buff, 0, n, buff, 0);
  egressMac.update(buff, 0, n);
  out.write(buff, 0, n);
byte[] pad = new byte[16];
if (padding < 16) {
  enc.processBytes(pad, 0, padding, buff, 0);
  egressMac.update(buff, 0, padding);
  out.write(buff, 0, padding);
byte[] macBuffer = new byte[egressMac.getDigestSize()];

  K2 = new byte[param.getMacKeySize() / 8];
  K = new byte[K1.length + K2.length];
  kdf.generateBytes(K, 0, K.length);
  K1 = new byte[((IESWithCipherParameters)param).getCipherKeySize() / 8];
  K2 = new byte[param.getMacKeySize() / 8];
  K = new byte[K1.length + K2.length];
  kdf.generateBytes(K, 0, K.length);
  System.arraycopy(K, 0, K1, 0, K1.length);
  System.arraycopy(K, K1.length, K2, 0, K2.length);
    cipher.init(true, new ParametersWithIV(new KeyParameter(K1), IV));
    cipher.init(true, new KeyParameter(K1));
  C = new byte[cipher.getOutputSize(inLen)];
  len = cipher.processBytes(in, inOff, inLen, C, 0);
  len += cipher.doFinal(C, len);
byte[] P2 = param.getEncodingV();
byte[] T = new byte[mac.getMacSize()];
  K2a = new byte[hash.getDigestSize()];
  hash.reset();
  hash.update(K2, 0, K2.length);
  hash.doFinal(K2a, 0);

public static byte[] decrypt(ECPoint ephem, BigInteger prv, byte[] IV, byte[] cipher, byte[] macData) throws InvalidCipherTextException {
  AESEngine aesFastEngine = new AESEngine();
  EthereumIESEngine iesEngine = new EthereumIESEngine(
      new ECDHBasicAgreement(),
      new ConcatKDFBytesGenerator(new SHA256Digest()),
      new HMac(new SHA256Digest()),
      new SHA256Digest(),
      new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
  byte[]         d = new byte[] {};
  byte[]         e = new byte[] {};
  IESParameters p = new IESWithCipherParameters(d, e, KEY_SIZE, KEY_SIZE);
  ParametersWithIV parametersWithIV =
      new ParametersWithIV(p, IV);
  iesEngine.init(false, new ECPrivateKeyParameters(prv, CURVE), new ECPublicKeyParameters(ephem, CURVE), parametersWithIV);
  return iesEngine.processBlock(cipher, 0, cipher.length, macData);
}

public static byte[] encrypt(ECPoint toPub, byte[] plaintext) throws InvalidCipherTextException, IOException {
  ECKeyPairGenerator eGen = new ECKeyPairGenerator();
  SecureRandom random = new SecureRandom();
  KeyGenerationParameters gParam = new ECKeyGenerationParameters(curve, random);
  eGen.init(gParam);
  byte[] IV = new byte[KEY_SIZE/8];
  new SecureRandom().nextBytes(IV);
  AsymmetricCipherKeyPair ephemPair = eGen.generateKeyPair();
  BigInteger prv = ((ECPrivateKeyParameters)ephemPair.getPrivate()).getD();
  ECPoint pub = ((ECPublicKeyParameters)ephemPair.getPublic()).getQ();
  EthereumIESEngine iesEngine = makeIESEngine(true, toPub, prv, IV);
  ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(curve, random);
  ECKeyPairGenerator generator = new ECKeyPairGenerator();
  generator.init(keygenParams);
  ECKeyPairGenerator gen = new ECKeyPairGenerator();
  gen.init(new ECKeyGenerationParameters(ECKey.CURVE, random));
  byte[] cipher = iesEngine.processBlock(plaintext, 0, plaintext.length);
  ByteArrayOutputStream bos = new ByteArrayOutputStream();
  bos.write(pub.getEncoded(false));
  bos.write(IV);
  bos.write(cipher);
  return bos.toByteArray();
}

  throw new DataLengthException("output buffer too small");
int outLen = digest.getDigestSize();
byte[] dig = new byte[digest.getDigestSize()];
  digest.update(C, 0, C.length);
  digest.update(shared, 0, shared.length);
    digest.update(iv, 0, iv.length);
  digest.doFinal(dig, 0);
digest.reset();

  dec.processBytes(headBuffer, 0, 16, headBuffer, 0);
  totalBodySize = headBuffer[0] & 0xFF;
  totalBodySize = (totalBodySize << 8) + (headBuffer[1] & 0xFF);
ingressMac.update(buffer, 0, frameSize);
dec.processBytes(buffer, 0, frameSize, buffer, 0);
int pos = 0;
long type = RLP.decodeLong(buffer, pos);
InputStream payload = new ByteArrayInputStream(buffer, pos, totalBodySize - pos);
int size = totalBodySize - pos;
byte[] macBuffer = new byte[ingressMac.getDigestSize()];

private static EthereumIESEngine makeIESEngine(boolean isEncrypt, ECPoint pub, BigInteger prv, byte[] IV) {
  AESEngine aesFastEngine = new AESEngine();
  EthereumIESEngine iesEngine = new EthereumIESEngine(
      new ECDHBasicAgreement(),
      new ConcatKDFBytesGenerator(new SHA256Digest()),
      new HMac(new SHA256Digest()),
      new SHA256Digest(),
      new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
  byte[]         d = new byte[] {};
  byte[]         e = new byte[] {};
  IESParameters p = new IESWithCipherParameters(d, e, KEY_SIZE, KEY_SIZE);
  ParametersWithIV parametersWithIV = new ParametersWithIV(p, IV);
  iesEngine.init(isEncrypt, new ECPrivateKeyParameters(prv, curve), new ECPublicKeyParameters(pub, curve), parametersWithIV);
  return iesEngine;
}