java和kotlin实现ECC加密

BouncyCastleProvider 下载地址：
https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on

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))

    }

}

java 实现ECC加密

    static{
        Security.addProvider(new BouncyCastleProvider());
    }

    //生成秘钥对
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC");
        keyPairGenerator.initialize(256, new SecureRandom());
        return keyPairGenerator.generateKeyPair();
    }

    //获取公钥(Base64编码)
    public static String getPublicKey(KeyPair keyPair){
        ECPublicKey publicKey = (ECPublicKey) keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    //获取私钥(Base64编码)
    public static String getPrivateKey(KeyPair keyPair){
        ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    //将Base64编码后的公钥转换成PublicKey对象
    public static ECPublicKey string2PublicKey(String pubStr) throws Exception{
        byte[] keyBytes = Base64.getDecoder().decode(pubStr.getBytes("UTF-8"));
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        return (ECPublicKey) keyFactory.generatePublic(keySpec);
    }

    //将Base64编码后的私钥转换成PrivateKey对象
    public static ECPrivateKey string2PrivateKey(String priStr) throws Exception{
        byte[] keyBytes = Base64.getDecoder().decode(priStr.getBytes("UTF-8"));
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        return (ECPrivateKey) keyFactory.generatePrivate(keySpec);
    }

    //公钥加密
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
        Cipher cipher = new NullCipher();
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(content);
    }

    //私钥解密
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher = new NullCipher();
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(content);
    }

    public static void main(String[] args) throws Exception {
        KeyPair keyPair = ECCUtil.getKeyPair();
        String publicKeyStr = ECCUtil.getPublicKey(keyPair);
        String privateKeyStr = ECCUtil.getPrivateKey(keyPair);
        System.out.println("ECC公钥Base64编码:" + publicKeyStr);
        System.out.println("ECC私钥Base64编码:" + privateKeyStr);

        ECPublicKey publicKey = string2PublicKey(publicKeyStr);
        ECPrivateKey privateKey = string2PrivateKey(privateKeyStr);

        byte[] publicEncrypt = publicEncrypt("hello world".getBytes(), publicKey);
        byte[] privateDecrypt = privateDecrypt(publicEncrypt, privateKey);
        System.out.println(new String(privateDecrypt));
    }