EthECIES

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val CipherKeyBits: Int

val CipherKeyBytes: Int

val Curve: Fp

val CurveInfo: (ECDomainParameters, Fp)

val CurveParams: ECDomainParameters

def DerivationVector: Array[Byte]

val DigestBits: Int

val DigestBytes: Int

val EmptyByteArray: Array[Byte]

val EncodedPublicKeyLen: Int

def EncodingVector: Array[Byte]

object EncryptedBlock

val KdfCounterStart: Int

val MacBits: Int

val MacBytes: Int

val MacKeyBits: Int

val MacKeyBytes: Int

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def createCipher(encrypt: Boolean, key: Array[Byte], initializationVector: Array[Byte]): BufferedBlockCipher

def createDigest(): Digest

def createMac(): Mac

def createRandom(): SecureRandom

def decryptBlock(to: ECPrivateKeyParameters, initializationVector: Array[Byte], mbSharedSecret: Option[Array[Byte]], bytes: Array[Byte], offset: Int, len: Int): Array[Byte]

Accepts the concatenation of an ephemeral public sender key, ciphertext and MAC in a byte array.

def decryptBlock(from: ECPublicKeyParameters, to: ECPrivateKeyParameters, initializationVector: Array[Byte], mbSharedSecret: Option[Array[Byte]], bytes: Array[Byte], offset: Int, len: Int): Array[Byte]

Requires the sender's known public key.

def doDecryptBlock(mbEmbeddedEncodedPublicKey: Option[Array[Byte]], sharedSecret: Array[Byte], derivationVector: Array[Byte], encodingVector: Array[Byte], initializationVector: Array[Byte], in: Array[Byte], inOffset: Int, inLen: Int): Array[Byte]

def doEncryptBlock(mbEmbeddedEncodedPublicKey: Option[Array[Byte]], sharedSecret: Array[Byte], derivationVector: Array[Byte], encodingVector: Array[Byte], initializationVector: Array[Byte], in: Array[Byte], inOffset: Int, inLen: Int): Array[Byte]

def ecdheSharedSecret(myPriv: EthPrivateKey, yourPub: EthPublicKey): Array[Byte]

def ecdheSharedSecret(myPriv: ECPrivateKeyParameters, yourPub: ECPublicKeyParameters): Array[Byte]

def encodePublicKey(pub: ECPublicKeyParameters): Array[Byte]

def encryptBlock(to: ECPublicKeyParameters, initializationVector: Array[Byte], mbSharedSecret: Option[Array[Byte]], bytes: Array[Byte], offset: Int, len: Int): Array[Byte]

Returns the concatenation of an ephemeral sender public key, ciphertext and MAC in a byte array.

def encryptBlock(from: ECPrivateKeyParameters, to: ECPublicKeyParameters, initializationVector: Array[Byte], mbSharedSecret: Option[Array[Byte]], bytes: Array[Byte], offset: Int, len: Int): Array[Byte]

Returns the concatenation of ciphertext and MAC in a byte array.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def generateEphemeralKeyPair(random: SecureRandom = createRandom()): (ECPrivateKeyParameters, ECPublicKeyParameters)

def generateInitializationVector(random: SecureRandom = createRandom()): Array[Byte]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def kdf(sharedSecret: Array[Byte], initializationVector: Array[Byte], len: Int): Array[Byte]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def readEncodedPublicKey(keyBytes: Array[Byte]): ECPublicKeyParameters

final def synchronized[T0](arg0: ⇒ T0): T0

implicit def toECPrivateKeyParameters(ethPriv: EthPrivateKey): ECPrivateKeyParameters

implicit def toECPublicKeyParameters(ethPub: EthPublicKey): ECPublicKeyParameters

def toEthKeyPair(rawKeyPair: (ECPrivateKeyParameters, ECPublicKeyParameters)): EthKeyPair

implicit def toEthPrivateKey(priv: ECPrivateKeyParameters): EthPrivateKey

implicit def toEthPublicKey(pub: ECPublicKeyParameters): EthPublicKey

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit