【Kotlin】加密解密3：非对称加密RSA

生成密钥对

新建RSACrypt

object RSACrypt {

}
fun main(args: Array<String>) {
    //如何生成密钥对
    val generator = KeyPairGenerator.getInstance("RSA")
    val keyPair = generator.genKeyPair()//声明密钥对
    val publicKey = keyPair.public//公钥
    val privateKey = keyPair.private//私钥

    println("publicKey="+Base64.encode(publicKey.encoded))
    println("privateKey="+Base64.encode(privateKey.encoded))
}

查看打印结果，可以看到非常长

加密和解密

import Base64
import java.security.KeyPairGenerator
import java.security.PrivateKey
import java.security.PublicKey
import javax.crypto.Cipher

//非对称加密RSA加密和解密
object RSACrypt {
    val transformation = "RSA"
    /**
     * 私钥加密
     * @param input 原文
     * @param privateKey 私钥
     */
    fun encryptByPrivateKey(input: String, privateKey: PrivateKey): String {
        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, privateKey)
        //加密/解密
        val encrypt = cipher.doFinal(input.toByteArray())
        return Base64.encode(encrypt)
    }

    /**
     * 公钥加密
     * @param input 原文
     * @param privateKey 公钥
     */
    fun encryptByPublicKey(input: String, publicKey: PublicKey): String {
        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, publicKey)
        //加密/解密
        val encrypt = cipher.doFinal(input.toByteArray())
        return Base64.encode(encrypt)
    }

    /**
     * 私钥解密
     * @param input 密文
     * @param privateKey 私钥
     */
    fun decryptByPrivateKey(input: String, privateKey: PrivateKey): String {
        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.DECRYPT_MODE, privateKey)
        //加密/解密
        val encrypt = cipher.doFinal(Base64.decode(input))
        return String(encrypt)
    }

    /**
     * 公钥解密
     * @param input 密文
     * @param privateKey 公钥
     */
    fun decryptByPublicKey(input: String, publicKey: PublicKey): String {
        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.DECRYPT_MODE, publicKey)
        //加密/解密
        val encrypt = cipher.doFinal(Base64.decode(input))
        return String(encrypt)
    }
}

fun main(args: Array<String>) {
    //如何生成密钥对
    val generator = KeyPairGenerator.getInstance("RSA")
    val keyPair = generator.genKeyPair()//声明密钥对
    val publicKey = keyPair.public//公钥
    val privateKey = keyPair.private//私钥

    println("publicKey=" + Base64.encode(publicKey.encoded))
    println("privateKey=" + Base64.encode(privateKey.encoded))
    
    val input = "新年快乐"
    //私钥加密
    val privateEncrypt = RSACrypt.encryptByPrivateKey(input, privateKey)
    println("私钥加密=" + privateEncrypt)
    //公钥加密
    val publicEncrypt = RSACrypt.encryptByPublicKey(input, publicKey)
    println("公钥加密=" + publicEncrypt)

    //公钥解密
    val publicDecrypt = RSACrypt.decryptByPublicKey(privateEncrypt, publicKey)
    println("公钥解密=" + publicDecrypt)
    //私钥解密
    val privateDecrypt = RSACrypt.decryptByPrivateKey(publicEncrypt, privateKey)
    println("私钥解密=" + privateDecrypt)
}

查看结果

分段加密和解密

之前input只有四个字，现在我们改成一串很长的字符串

	......
    val input = "新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐"
    println(input.length)
    println(input.toByteArray().size)
    ......
}

查看打印结果

因为RSA机密很慢，它对加密有要求，文件越大，内容越多加密越慢

解决的办法就是分段加密和分段解密

//非对称加密RSA加密和解密
object RSACrypt {
    val transformation = "RSA"
    val ENCRYPT_MAX_SIZE = 245//每次最大加密长度
    /**
     * 私钥加密
     * @param input 原文
     * @param privateKey 私钥
     */
    fun encryptByPrivateKey(input: String, privateKey: PrivateKey):String {
        val byteArray = input.toByteArray()

        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, privateKey)
        //加密/解密 分段加密
        //val encrypt = cipher.doFinal(input.toByteArray())

        var temp:ByteArray? = null
        var offset = 0//当前偏移位置
        var bos = ByteArrayOutputStream()
        while (byteArray.size-offset>0){  //没有加密完成
            //每次加密245个字节
            if(byteArray.size-offset>= ENCRYPT_MAX_SIZE){
                //剩余部分大于245
                //bytearray，偏移，加密245个字节
                temp = cipher.doFinal(input.toByteArray(),offset, ENCRYPT_MAX_SIZE)
                //重新计算offset
                offset+= ENCRYPT_MAX_SIZE
            }else{
                temp = cipher.doFinal(input.toByteArray(),offset,byteArray.size- offset)
                offset = byteArray.size
            }
            //存储到临时缓冲区
            bos.write(temp)
        }
        bos.close()
        return Base64.encode(bos.toByteArray())
    }

    /**
     * 公钥加密
     * @param input 原文
     * @param privateKey 公钥
     */
    fun encryptByPublicKey(input: String, publicKey: PublicKey):String {
        ......//其余代码同上
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, publicKey)
       ......
    }
}

fun main(args: Array<String>) {
    //如何生成密钥对
    val generator = KeyPairGenerator.getInstance("RSA")
    val keyPair = generator.genKeyPair()//声明密钥对
    val publicKey = keyPair.public//公钥
    val privateKey = keyPair.private//私钥

    println("publicKey=" + Base64.encode(publicKey.encoded))
    println("privateKey=" + Base64.encode(privateKey.encoded))

    //通过私钥做加密操作
    //私钥加密
    val input = "新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐"
    println(input.length)
    println(input.toByteArray().size)
    val encrypt = RSACrypt.encryptByPrivateKey(input,privateKey)
    println("私钥加密="+encrypt)
    //公钥加密
    val publicEncrypt = RSACrypt.encryptByPublicKey(input,publicKey)
    println("公钥加密="+publicEncrypt)
}

分段解密

//非对称加密RSA加密和解密
object RSACrypt {
    val transformation = "RSA"
    val ENCRYPT_MAX_SIZE = 245//每次最大加密长度
    val DECRYPT_MAX_SIZE = 256//每次最大解密长度

    /**
     * 私钥分段加密
     * @param input 原文
     * @param privateKey 私钥
     */
    fun encryptByPrivateKey2(input: String, privateKey: PrivateKey): String {
        val byteArray = input.toByteArray()

        //创建cipher对象
        var cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, privateKey)
        //分段加密
        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        var bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {  //没有加密完成
            //每次加密245个字节
            if (byteArray.size - offset >= ENCRYPT_MAX_SIZE) {
                //剩余部分大于245
                //bytearray，偏移，加密245个字节
                temp = cipher.doFinal(byteArray, offset, ENCRYPT_MAX_SIZE)
                //重新计算offset
                offset += ENCRYPT_MAX_SIZE
            } else {
                temp = cipher.doFinal(byteArray, offset, byteArray.size - offset)
                offset = byteArray.size
            }
            //存储到临时缓冲区
            bos.write(temp)
        }
        bos.close()
        return Base64.encode(bos.toByteArray())
    }

    /**
     * 公钥分段加密
     * @param input 原文
     * @param privateKey 公钥
     */
    fun encryptByPublicKey2(input: String, publicKey: PublicKey): String {
        val byteArray = input.toByteArray()

        var cipher = Cipher.getInstance(transformation)
        cipher.init(Cipher.ENCRYPT_MODE, publicKey)

        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        var bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {  //没有加密完成
            if (byteArray.size - offset >= ENCRYPT_MAX_SIZE) {
                temp = cipher.doFinal(byteArray, offset, ENCRYPT_MAX_SIZE)
                offset += ENCRYPT_MAX_SIZE
            } else {
                temp = cipher.doFinal(byteArray, offset, byteArray.size - offset)
                offset = byteArray.size
            }
            bos.write(temp)
        }
        bos.close()
        return Base64.encode(bos.toByteArray())
    }

    /**
     * 公钥分段解密
     * @param input 密文
     * @param privateKey 公钥
     */
    fun decryptByPublicKey2(input: String, publicKey: PublicKey): String {
        val byteArray = Base64.decode(input)

        var cipher = Cipher.getInstance(transformation)
        cipher.init(Cipher.DECRYPT_MODE, publicKey)

        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        var bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {  //没有解密完成
            if (byteArray.size - offset >= DECRYPT_MAX_SIZE) {
                temp = cipher.doFinal(byteArray, offset, DECRYPT_MAX_SIZE)
                offset += DECRYPT_MAX_SIZE
            } else {
                temp = cipher.doFinal(byteArray, offset, byteArray.size - offset)
                offset = byteArray.size
            }
            bos.write(temp)
        }
        bos.close()
        return String(bos.toByteArray())
    }

    /**
     * 私钥分段解密
     * @param input 密文
     * @param privateKey 私钥
     */
    fun decryptByPrivateKey2(input: String, privateKey: PrivateKey): String {
        val byteArray = Base64.decode(input)

        var cipher = Cipher.getInstance(transformation)
        cipher.init(Cipher.DECRYPT_MODE, privateKey)

        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        var bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {  //没有解密完成
            if (byteArray.size - offset >= DECRYPT_MAX_SIZE) {
                temp = cipher.doFinal(byteArray, offset, DECRYPT_MAX_SIZE)
                offset += DECRYPT_MAX_SIZE
            } else {
                temp = cipher.doFinal(byteArray, offset, byteArray.size - offset)
                offset = byteArray.size
            }
            bos.write(temp)
        }
        bos.close()
        return String(bos.toByteArray())
    }


}

fun main(args: Array<String>) {
    //如何生成密钥对
    val generator = KeyPairGenerator.getInstance("RSA")
    val keyPair = generator.genKeyPair()//声明密钥对
    val publicKey = keyPair.public//公钥
    val privateKey = keyPair.private//私钥

    println("publicKey=" + Base64.encode(publicKey.encoded))
    println("privateKey=" + Base64.encode(privateKey.encoded))

    val long_input = "新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐新年快乐"
    //私钥分段加密
    val privateEncrypt2 = RSACrypt.encryptByPrivateKey2(long_input, privateKey)
    println("私钥分段加密=" + privateEncrypt2)
    //公钥分段加密
    val publicEncrypt2 = RSACrypt.encryptByPublicKey2(long_input, publicKey)
    println("公钥分段加密=" + publicEncrypt2)

    //公钥解密
    val publicDecrypt2 = RSACrypt.decryptByPublicKey2(privateEncrypt2, publicKey)
    println("公钥分段解密=" + publicDecrypt2)
    //私钥解密
    val privateDecrypt2 = RSACrypt.decryptByPrivateKey2(publicEncrypt2, privateKey)
    println("私钥分段解密=" + privateDecrypt2)
}

保存密钥对

 //保存密钥对
    val publicKeyString = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnBAaE7ji9zqSfhgarM9IKqpvL/1/EXELBSf6ku4G4wGwiFW9ItpMVKz0LTl/WuIx9HYkv/Z4ADjjUCxeKGwYrc8y3nxhnZhqg9DZn/Qt38lGmFEmVQXqnWIyDi02BCKU0z8yKAVnCk+670jZJrxEDqVnUq1YgAyp0GXEk/j8VRr/9L4NRXHzSvLXC+0gzL5oByHvJkus3XQRphFMJY9eBQ3FQAVv7F3P5pX0Qd+OTtO3C8XIP8g+5B5q/WcB8rVm/ZjVDzNkPNEGJfSp+wKkm8Gk3BEcd5AIlDEDKdQnkhitBpKEUoPRuANHvRu1KF2d/C1DIwFQSAyp/rdJB2d/VQIDAQAB"
    val privateKeyString = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcEBoTuOL3OpJ+GBqsz0gqqm8v/X8RcQsFJ/qS7gbjAbCIVb0i2kxUrPQtOX9a4jH0diS/9ngAOONQLF4obBitzzLefGGdmGqD0Nmf9C3fyUaYUSZVBeqdYjIOLTYEIpTTPzIoBWcKT7rvSNkmvEQOpWdSrViADKnQZcST+PxVGv/0vg1FcfNK8tcL7SDMvmgHIe8mS6zddBGmEUwlj14FDcVABW/sXc/mlfRB345O07cLxcg/yD7kHmr9ZwHytWb9mNUPM2Q80QYl9Kn7AqSbwaTcERx3kAiUMQMp1CeSGK0GkoRSg9G4A0e9G7UoXZ38LUMjAVBIDKn+t0kHZ39VAgMBAAECggEAKr3qNm6Tkrxy9J/rZlra2/yTuSQHUiKQrxfU87rHHhMPYzeANnRtJV+8/EncDGsY3WgiBoUdNopeD04nd5Crbabquq58Gaptua5QfBNnIPxCHmNTSUP2jqYfKWzOd3F1KyoKtZVNNDDD9NcRyh8T0KMSWj1pmKBfPdkxbolpqnDswmDL77KjCTnHTJRjQQux3SihHuOJ4MvgHnHjqjSLZL+6qnUJw838AnhZiIGLlIhaSPbEtuZH7Nk37zodjq+7nBvH0cCvX/XqGRQC2oZeCIWyDv3J5HE4V9PEjiktQVY32f+YZGm3C2EAWqhFZYXDdStYEBCM/UM7EJiGep6OoQKBgQDp9kqJfATLBqnTHzK5SywVPXU0w/fZD4Z9KnvTKhwpivjp8zdcSuiG7F3P8mXIenjbxUyaL2x/9PFgBD878Cj9tXkLnaGb9qwJKgHBCoNwqngg7Z4HTmeDklLfnuUACyf+XX+5V7XHDpoA9tkZflQp267/I+ZLfDAPqSmdJl7l/QKBgQCqw14S1X+o452gx7FK+YVjctndhRN6SY9gZBuC4Q+oU/v2YdFs3CcHVZSijRMqiW8rTGQ/OgFdtD2ef+TMmiRRfnHpgz94iWOAIRKsfJwem3G6SnIZpnQzPSuQshbFIto+lOKqSiV3DnJzfiAI4Eop2RyQMigyVu77lEzyTkySOQKBgQDKfyxGULwJSUwlegQ6EhEmlRnjwJW9Hk3l+aZQv0q+vhTw0FyjGgal+OC9geyMl0wR03OYo+FB4qwj0ak1ZIjmBnKtFhLxXY/LIrt/7GyVUEZHIcK8SiUX4Mav2+QSpJVJ+Hz62ypvDnlGymBfS1LnI8gT9mt1/BfRBjYJWVObtQKBgC3dHy0rzofL6pA+Ui3y6pKVTFKk5WBY1XtsJ791N0FcnTXFe/wi/RCJOcyW22j3VLZqZBpfN/K08D/b1dXmKI8CyRGQwMFdFS5as6tEJKJL2bXRPOgKvvbsHQFV86uq+rcIQgC+vWVGqhK+81eu9fxbZcKM1iL/GlzTrf7+bK5xAoGAU+am9p4hK5VUwgEOLlLeXTi/UZCoql9OnQC0yCjR2Uouq0ip3l+6kK2219FCuC1DGE0zukAv4Th81wzOGNm4uTVyXy81a7IxT5q5+ZiFttERrMCohTfJesOTkfM18WP33pqG1sv9TITRO/DaqK39s7dMVQH4qKVctQuC1/aD4yA="
    //转成密钥对对象
    val kf = KeyFactory.getInstance("RSA")
    val privateKey:PrivateKey = kf.generatePrivate(PKCS8EncodedKeySpec(Base64.decode(privateKeyString)))
    val publicKey:PublicKey = kf.generatePublic(X509EncodedKeySpec(Base64.decode(publicKeyString)))
    //val publicKey:PublicKey = null

    val input = "新年快乐"

    //私钥加密
    val privateEncrypt = RSACrypt.encryptByPrivateKey(input, privateKey)
    println("私钥加密=" + privateEncrypt)
    //公钥加密
    val publicEncrypt = RSACrypt.encryptByPublicKey(input, publicKey)
    println("公钥加密=" + publicEncrypt)

    //公钥解密
    val publicDecrypt = RSACrypt.decryptByPublicKey(privateEncrypt, publicKey)
    println("公钥解密=" + publicDecrypt)
    //私钥解密
    val privateDecrypt = RSACrypt.decryptByPrivateKey(publicEncrypt, privateKey)
    println("私钥解密=" + privateDecrypt)