kotlin實現ECC加密

package data


import org.bouncycastle.jce.provider.BouncyCastleProvider
import java.nio.charset.Charset
import java.security.*
import java.security.interfaces.ECPrivateKey
import java.security.interfaces.ECPublicKey
import java.security.spec.PKCS8EncodedKeySpec
import java.security.spec.X509EncodedKeySpec
import java.util.*
import javax.crypto.Cipher
import javax.crypto.NullCipher

/**
 * @author BrokerXu
 * @description ECC加密工具類
 */
object ECKeyUtils {


    //生成祕鑰對

    val keyPair: KeyPair
        @Throws(Exception::class)
        get() {

            val keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC")

            keyPairGenerator.initialize(256, SecureRandom())

            return keyPairGenerator.generateKeyPair()

        }


    init {

        Security.addProvider(BouncyCastleProvider())

    }

    //獲取公鑰(Base64編碼)

    fun getPublicKey(keyPair: KeyPair): String {

        val publicKey = keyPair.public as ECPublicKey

        val bytes = publicKey.encoded

        return base64Encoder(bytes)

    }

    //獲取私鑰(Base64編碼)

    fun getPrivateKey(keyPair: KeyPair): String {

        val privateKey = keyPair.private as ECPrivateKey

        val bytes = privateKey.encoded

        return base64Encoder(bytes)

    }

    //將Base64編碼後的公鑰轉換成PublicKey對象

    @Throws(Exception::class)
    fun string2PublicKey(pubStr: String): ECPublicKey {

        val keyBytes = base64Deconder(pubStr)

        val keySpec = X509EncodedKeySpec(keyBytes)

        val keyFactory = KeyFactory.getInstance("EC", "BC")

        return keyFactory.generatePublic(keySpec) as ECPublicKey

    }

    //將Base64編碼後的私鑰轉換成PrivateKey對象

    @Throws(Exception::class)
    fun string2PrivateKey(priStr: String): ECPrivateKey {

        val keyBytes = base64Deconder(priStr)

        val keySpec = PKCS8EncodedKeySpec(keyBytes)

        val keyFactory = KeyFactory.getInstance("EC", "BC")

        return keyFactory.generatePrivate(keySpec) as ECPrivateKey

    }

    //公鑰加密

    @Throws(Exception::class)
    fun publicEncrypt(content: ByteArray, publicKey: PublicKey): ByteArray {

//        val cipher = Cipher.getInstance("ECIES", "BC")

        val cipher = NullCipher()

                cipher.init(Cipher.ENCRYPT_MODE, publicKey)

        return cipher.doFinal(content)

    }

    //私鑰解密

    @Throws(Exception::class)
    fun privateDecrypt(content: ByteArray, privateKey: PrivateKey): ByteArray {

//        val cipher = Cipher.getInstance("ECIES", "BC")

        val cipher = NullCipher()

        cipher.init(Cipher.DECRYPT_MODE, privateKey)

        return cipher.doFinal(content)

    }


    /**
     * base64編碼
     */
    fun base64Encoder(value:String):ByteArray{

        val encode = Base64.getEncoder().encode(value.toByteArray())

        return encode
    }

    /**
     * base64編碼
     */
    fun base64Encoder(value:ByteArray):String{

        val encode = Base64.getEncoder().encodeToString(value)

        return encode
    }




    /**
     * base64解碼
     */
    fun base64Deconder(value:String):ByteArray{

        val encode = Base64.getDecoder().decode(value.toByteArray())

        return encode
    }

    /**
     * base64解碼
     */
    fun base64Deconder(value:ByteArray):String{

        val encode = Base64.getDecoder().decode(value).toString(Charset.defaultCharset())

        return encode
    }


    @Throws(Exception::class)
    @JvmStatic
    fun main(args: Array<String>) {

        val keyPair = ECKeyUtils.keyPair

        val publicKeyStr = ECKeyUtils.getPublicKey(keyPair)

        val privateKeyStr = ECKeyUtils.getPrivateKey(keyPair)

        println("ECC公鑰Base64編碼:$publicKeyStr")

        println("ECC私鑰Base64編碼:$privateKeyStr")

        val publicKey = string2PublicKey(publicKeyStr)

        val privateKey = string2PrivateKey(privateKeyStr)

        val publicEncrypt = publicEncrypt("關關雎鳩，在河之洲，窈窕淑女，君子好逑。".toByteArray(), publicKey)

        val privateDecrypt = privateDecrypt(publicEncrypt, privateKey)

        println(String(privateDecrypt))

    }

}