RSA非对称加密解，分段加密解密

RSA 公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。1987年7月首次在美国公布，当时他们三人都在麻省理工学院工作实习。RSA就是他们三人姓氏开头字母拼在一起组成的。

RSA是目前最有影响力和最常用的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被 ISO推荐为公钥数据加密标准。

今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。但在分布式计算和量子计算机理论日趋成熟的今天，RSA加密安全性受到了挑战和质疑。

RSA算法基于一个十分简单的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

/**
 * 非对称加密
 */
object RSACrypt {
    val transformation = "RSA"
    val ENCRYPT_MAX_SIZE = 117//加密不能超过117
    val DECRYPT_MAX_SIZE = 128//解密不能超过128
    /**
     * 私钥加密
     * @input 需要加密的内容
     * @privateKey 私钥
     */
    fun encryptByPrivsteKey(input: String, privateKey: PrivateKey): String {

        val byteArray = input.toByteArray()

        //创建cipher
        val cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, privateKey)
        //加密解密  分段加密
        //val encrypt = cipher.doFinal(input.toByteArray())
        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        val bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {//没加密完
            //每次最大加密117个字节
            if (byteArray.size - offset >= ENCRYPT_MAX_SIZE) {
                //剩余部分大于117
                //加密完整的117字节
                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())
    }

    /**
     * 私钥解密
     * @input 公钥生成的密文
     * @privateKey 私钥
     */
    fun decryptByPrivsteKey(input: String, privateKey: PrivateKey): String {

        val byteArray = Base64.decode(input)

        //创建cipher
        val cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.DECRYPT_MODE, privateKey)
        //加密解密  分段解密
        //val encrypt = cipher.doFinal(input.toByteArray())
        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        val bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {//没加密完
            //每次最大加密128个字节
            if (byteArray.size - offset >= DECRYPT_MAX_SIZE) {
                //剩余部分大于128
                //加密完整的128字节
                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())
    }


    /**
     * 公钥加密
     * @input 需要加密的内容
     * @publicKey 公钥
     */
    fun encryptByPublicKey(input: String, publicKey: PublicKey): String {

        val byteArray = input.toByteArray()
        //创建cipher
        val cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.ENCRYPT_MODE, publicKey)
        //加密解密  分段加密
        //val encrypt = cipher.doFinal(input.toByteArray())
        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        val bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {//没加密完
            //每次最大加密117个字节
            if (byteArray.size - offset >= ENCRYPT_MAX_SIZE) {
                //剩余部分大于117
                //加密完整的117字节
                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())
    }

    /**
     * 公钥解密
     * @input 私钥生成的密文
     * @privateKey 私钥
     */
    fun decryptByPublicKey(input: String, publicKey: PublicKey): String {

        val byteArray = Base64.decode(input)

        //创建cipher
        val cipher = Cipher.getInstance(transformation)
        //初始化cipher
        cipher.init(Cipher.DECRYPT_MODE, publicKey)
        //加密解密  分段解密
        //val encrypt = cipher.doFinal(input.toByteArray())
        var temp: ByteArray? = null
        var offset = 0//当前偏移位置
        val bos = ByteArrayOutputStream()
        while (byteArray.size - offset > 0) {//没加密完
            //每次最大加密128个字节
            if (byteArray.size - offset >= DECRYPT_MAX_SIZE) {
                //剩余部分大于128
                //加密完整的128字节
                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 keyPain = generator.genKeyPair()//生成秘钥
//    val publicKey = keyPain.public//公钥
//    val privateKey = keyPain.private//私钥
//    println("publicKey:" + Base64.encode(publicKey.encoded))
//    println("privateKey:" + Base64.encode(privateKey.encoded))

    val publicKeyStr = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDymOuE7z9SfGv3Czq1ZAwzukNknR1iVTBZurJ6BTh9cBiQUczZ9U4HgBtgIWMRaLNeFjkFMszQz/uDmWQXMJbcsYuSAEJNxUn5KuHAp2YEWfV2CXTj/3I/Q9rhGVq+aLs0rgfCvVXoxFjJV+uGPtzXxhVZTahCcwUo20MSPqI0WwIDAQAB"
    val privateKeyStr = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAPKY64TvP1J8a/cLOrVkDDO6Q2SdHWJVMFm6snoFOH1wGJBRzNn1TgeAG2AhYxFos14WOQUyzNDP+4OZZBcwltyxi5IAQk3FSfkq4cCnZgRZ9XYJdOP/cj9D2uEZWr5ouzSuB8K9VejEWMlX64Y+3NfGFVlNqEJzBSjbQxI+ojRbAgMBAAECgYAT4bpzk5Px86Z5gZ8XHJLvblV1mna9B1RGFknoPCNMDHLG6R1Lw5HYhYQ41aOj2pvQmyujJG2qs1DekSSlzeKfHMgoiHiKO/LPLCe4QgbkCsxtTy+SloVM/EirMBCwoPjMwYPqoxVm1a38kCqNgiitMpGooTXflCR0jgGvR9ej+QJBAPwTrCkk6SupWERxQG7yBdCIO9lyWzer9DPa2+JmMcoNydov4bq2ZUCgpum8JkAkmhonM1Oz8x6OFOwcbzHnyZ0CQQD2X3qpvF1Iyc3M/gqZcOSTORQTRkZVSt5ctPnJw6lIGax+HMr9YNccuiwlfi2UtSA0NOtC5yozDS8s9Xt2yHBXAkAzfKkrdjiSDHLU9/TbNF/vqgPfdDYhduPYO5mx8oG07YAPKryGcH7Z5nZxQ1bkvxUixmL7c8Pyt76aQ2yK2vcZAkBLoDFR6t0jm7aNhymPwiSXwHyWEgtC4TFyeab3NRVAaYkWSRZSQqilS8yDUcECFbsl61yP889zTke94Die1JYPAkEAjy3tzsbUeVCMF5CTfAklXSoJbJMZiWvW0S5lolAV9TOVmXFsW+itONAivg7k6HYkxGQF78u6JdcCf5y5p1DqSQ=="

    val kf = KeyFactory.getInstance("RSA")
    val privateKey =  kf.generatePrivate(PKCS8EncodedKeySpec(Base64.decode(privateKeyStr)))
    val publicKey = kf.generatePublic(X509EncodedKeySpec(Base64.decode(publicKeyStr)))
    //加密不能超过117个字节  可以采取分段加密方式解决这个问题
    val inpit = "RSA加密 RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密RSA加密"
    val encryptByPrivsteKey = RSACrypt.encryptByPrivsteKey(inpit, privateKey)
    println("RSA私钥加密:" + encryptByPrivsteKey)


    val encryptByPublicKey = RSACrypt.encryptByPublicKey(inpit, publicKey)
    println("RSA公钥加密:" + encryptByPublicKey)


    val decryptByPrivsteKey = RSACrypt.decryptByPrivsteKey(encryptByPublicKey, privateKey)
    println("RSA私钥解密:" + decryptByPrivsteKey)

    val decryptByPublicKey = RSACrypt.decryptByPublicKey(encryptByPrivsteKey, publicKey)
    println("RSA公钥解密:" + decryptByPublicKey)
}

Base64工具类

转发表明出处

点击下载demo

android互助群：

RSA非对称加密解，分段加密解密

猜你喜欢