【加密与解密】【08】Java加密算法详解

Java加密库

• JDK
• Apache Commons Codec
• Bouncy Castle

// commons codec
api("commons-codec:commons-codec:1.17.0")
// bouncy castle provider
api("org.bouncycastle:bcprov-jdk18on:1.71")

// register bouncy castle provider
Security.addProvider(BouncyCastleProvider())
// use bouncy castle provider
KeyGenerator.getInstance(algorithm, "BC")
Cipher.getInstance(algorithm, "BC")

摘要算法

常用的摘要算法有

• MD，Message Digest，如MD5
• MD5生成的摘要为128位，对应的十六进制字符串为32位
• MD5已被破解，适合对安全性要求不高的场景，常用于校验文件
• SHA，Secure Hash Algorithm，如SHA256
• SHA256生成的摘要为256位，对应的十六进制字符串为64位
• SHA256常用于数字签名，账号密码加密
• SHA算法在MD算法的基础上演进而来，安全性更高
• SHA1算法已被破解，SHA2未来也大概率会被破解，目前SHA2算法仍然是安全的
• SHA2系列算法包括SHA224，SHA256，SHA384，SHA512
• MAC，Message Authentication Code，消息认证码，也叫HMAC
• MAC算法在MD或SHA的基础上，加入秘钥机制，即持有秘钥才能生成摘要
• MAC可以和MD或SHA来组合使用，比如HmacMD5，HmacSHA256，生成的摘要程度为MD或SHA的长度
• CRC，Cyclic Redundancy Check，循环冗余校验，如CRC32
• CRC算法生成一个简短的摘要，放在原数据的结尾，一起发送给接收方
• CRC算法多用于硬件和通信领域，一般用于校验数据完整性
• CRC32生成的摘要为32位，对应的十六进制字符串为8位
• JDK支持以上所有摘要算法的常用版本

MD5代码实现

import java.io.FileInputStream
import java.security.MessageDigest

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    val digest = MessageDigest.getInstance("MD5")
    val encrypted = digest.digest(origin)
    val md5 = encrypted.toHexString()
    println(md5)
}

SHA256代码实现

和MD5一样，只是algorithm不一样

val digest = MessageDigest.getInstance("SHA256")

HmacMD5代码实现

@OptIn(ExperimentalStdlibApi::class)
fun digestByMac() {
    val input = "Hello World".encodeToByteArray()
    // generate key
    val generator = KeyGenerator.getInstance("HmacMD5")
    val key = generator.generateKey()
    // digest by mac
    val mac = Mac.getInstance(key.algorithm)
    mac.init(key)
    val output = mac.doFinal(input)
    println(output.toHexString())
    // verify by mac
    val spec = SecretKeySpec(key.encoded, key.algorithm)
    val verifyMac = Mac.getInstance(key.algorithm)
    verifyMac.init(spec)
    val verifyOutput = verifyMac.doFinal(input)
    println(verifyOutput.toHexString())
}

CRC32代码实现

import java.io.FileInputStream
import java.util.zip.CRC32

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    val crc32 = CRC32()
    crc32.update(origin)
    val checksum = crc32.value.toInt().toHexString()
    println(checksum)
}

对称加密算法

常用的对称加密算法有

• Base64，将字节编码为Base64字符的一套算法
• Base64不算严格意义上的对称加密，因为它没有秘钥，但是字符映射表间接充当了秘钥的角色
• Base64字符仅包含大小写字母，数字，+，/，-，共64个字符
• 由于Base64包含的都是基本字符，所以兼容性特别强，Base64主要用来解决数据传输过程中的编码问题，而不是加密
• DES，最早规模化使用的加密算法
• DES的密码较短，加密算法不完全公开，因此遭到安全性的质疑，并且存在安全漏洞
• DESede，基于DES算法的三重迭代，来提升安全性，但同时也导致的加密效率较低的问题
• AES，为了替代DES而诞生的一种算法
• AES加密效率高，内存占用低，安全性高于DES算法，目前被广泛认可与应用
• 并且，AES算法成为后来许多算法实现的主要参考模型
• IDEA，International Data Encryption Algorithm，国际数据加密标准
• IDEA算法早于AES，作为DES的替代算法出现
• IDEA不是基于DES的改良而产生的，而是完全独创了一套新的算法
• IDEA不是在美国发展起来的算法，没有遭到法律出口限制，在使用范围上更加灵活
• 电子邮件加密协议PGP，即是使用了IDEA算法
• RC，Rivest Cipher，AES同时代的竞争方案之一
• Twofish，AES同时代的竞争方案之一，前身是Blowfish
• PBE，Password Baed Encryption，基于口令的加密算法
• PBE采用随机数，再拼凑多重加密的方式，来保证数据的安全性
• 作为口令的随机数被称作为盐（Salt），同一个随机数不能被使用两次
• 盐在固定秘钥的基础上引入了变数，这样就加大了破解难度
• PBE是一个综合性算法，加密过程会用到其它算法，比如PBEWithMD5AndDES
• JDK支持DES，AES，Blowfish，RC，PBE算法

查看JDK支持的算法

Security.getAlgorithms("KeyGenerator")
Security.getAlgorithms("KeyPairGenerator")
Security.getAlgorithms("Cipher")
Security.getAlgorithms("Signature")

Base64代码实现

import java.io.FileInputStream
import java.util.Base64

fun main() {
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // encode bytes to base64 string
    val encoder = Base64.getEncoder()
    val encoded = encoder.encodeToString(origin)
    println(encoded)
    // decode base64 string to bytes
    val decoder = Base64.getDecoder()
    val decoded = decoder.decode(encoded)
    println(String(decoded))
}

DES代码实现

import java.io.FileInputStream
import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.spec.SecretKeySpec

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val algorithm = "DES"
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate encrypt key
    val generator = KeyGenerator.getInstance(algorithm)
    val secretKey = generator.generateKey()
    // encrypt
    val cipher1 = Cipher.getInstance(algorithm)
    cipher1.init(Cipher.ENCRYPT_MODE, secretKey)
    val encrypted = cipher1.doFinal(origin)
    // generate decrypt key
    val keySpec = SecretKeySpec(secretKey.encoded, algorithm)
    // decrypt
    val cipher2 = Cipher.getInstance(algorithm)
    cipher2.init(Cipher.DECRYPT_MODE, keySpec)
    val decrypted = cipher2.doFinal(encrypted)
    println(decrypted.toHexString() == origin.toHexString())
}

DESede代码实现

和DES完全一致，算法名称改为DESede或TripleDES即可

AES代码实现

和DES完全一致，算法名称改为AES即可

RC代码实现

和DES完全一致，算法名称改为RC2即可

IDEA代码实现

JDK没有提供IDEA算法的实现，此时就轮到Bouncy Castle出场了

import org.bouncycastle.jce.provider.BouncyCastleProvider
import java.io.FileInputStream
import java.security.Security
import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.spec.SecretKeySpec

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val provider = "BC"
    val keyAlgorithm = "IDEA"
    val cipherAlgorithm = "IDEA"
    // register bouncy castle provider
    Security.addProvider(BouncyCastleProvider())
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate encrypt key
    val generator = KeyGenerator.getInstance(keyAlgorithm, provider)
    val secretKey = generator.generateKey()
    // encrypt
    val cipher1 = Cipher.getInstance(cipherAlgorithm, provider)
    cipher1.init(Cipher.ENCRYPT_MODE, secretKey)
    val encrypted = cipher1.doFinal(origin)
    // generate decrypt key
    val keySpec = SecretKeySpec(secretKey.encoded, keyAlgorithm)
    // decrypt
    val cipher2 = Cipher.getInstance(cipherAlgorithm, provider)
    cipher2.init(Cipher.DECRYPT_MODE, keySpec)
    val decrypted = cipher2.doFinal(encrypted)
    println(decrypted.toHexString() == origin.toHexString())
}

PBE代码实现

PBE是加盐算法，因此需要用到密码和盐两个参数来加解密

import java.io.FileInputStream
import java.security.SecureRandom
import javax.crypto.Cipher
import javax.crypto.SecretKeyFactory
import javax.crypto.spec.PBEKeySpec
import javax.crypto.spec.PBEParameterSpec

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val keyAlgorithm = "PBEWithMD5AndDES"
    val cipherAlgorithm = "PBEWithMD5AndDES"
    val password = "123456"
    val salt = SecureRandom().generateSeed(8)
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate secret key
    val keySpec = PBEKeySpec(password.toCharArray())
    val keyFactory = SecretKeyFactory.getInstance(keyAlgorithm)
    val secretKey = keyFactory.generateSecret(keySpec)
    // encrypt
    val algorithmSpec = PBEParameterSpec(salt, 100)
    val cipher1 = Cipher.getInstance(cipherAlgorithm)
    cipher1.init(Cipher.ENCRYPT_MODE, secretKey, algorithmSpec)
    val encrypted = cipher1.doFinal(origin)
    // decrypt
    val cipher2 = Cipher.getInstance(cipherAlgorithm)
    cipher2.init(Cipher.DECRYPT_MODE, secretKey, algorithmSpec)
    val decrypted = cipher2.doFinal(encrypted)
    println(decrypted.toHexString() == origin.toHexString())
}

非对称加密算法

常用的非对称加密算法有

• DH算法，Diffie Hellman
• DH算法基于离散对数的数学基础，通过模运算和幂运算实现秘钥交换
• DH算法只能用于秘钥交换，不能用于数据解密
• DH算法最早的非对称加密算法，为非对称加密算法奠定了理论基础
• 几乎所有的非对称加密算法，都是基于数学问题的求解来设计的
• RSA算法，Rivest Shamir Adleman
• RSA算法基于大数因子分解问题
• RSA算法技能既能用于数据加密，也能用于数字签名
• RAS算法是应用范围最为广泛的非对称加密算法
• RSA虽然能用于数据加密，但由于性能原因，只允许加密245字节以内的数据
• 因此RSA的主流用法，还是用于数字签名
• DSA算法，Digital Signature Algorithm
• DSA算法基于离散对数问题
• DSA算法的前身是ElGamal算法
• DSA算法主要用于数字签名
• DSA算法的私钥，不能解密公钥加密的数据，因此不具备完整加密功能
• ECC算法，Elliptical Curve Cryptography
• ECC算法基于椭圆曲线问题
• ECC秘钥生成速度比RSA快，安全性也比RSA高，硬件占用比RSA低，但是普及度没RSA广
• ECC算法技能既能用于数据加密，也能用于数字签名
• ECC算法用于加密时，只允许公钥加密，私钥解密
• ECDH算法，借鉴ECC算法改良的DH算法
• ECDH算法沿用DH算法的思路，但基于ECC椭圆曲线问题来实现
• ECDSA算法，借鉴ECC算法改良的DSA算法
• JDK支持支持RSA和DSA算法

DH秘钥交换算法数学原理

DH秘钥交换算法，是一个通过公钥私钥，来协商对称秘钥的一种算法

• 参数g，p是算法共享参数，所有人都知道
• publicA = g^privateA mod p
• publicB = g^privateB mod p
• shareA = publicB^privateA mod p
• shareB = publicA^privateB mod p
• 通过数学理论可以论证，shareA==shareB
• 因此可以使用shareA和shareB作为AB通信时的SecretKey
• 由于shareA和shareB的生成依赖于自己的私钥和对方的公钥，对每个人都不一样，并且不存在网络交换过程，因为是安全的

DH算法代码实现

DH算法主要借助KeyAgreement类来实现

KeyAgreement是一个秘钥协商工具类，用于交换公钥，以生成相同的对称秘钥

@OptIn(ExperimentalStdlibApi::class)
fun swapSecretKey() {
    System.setProperty("jdk.crypto.KeyAgreement.legacyKDF", "true")
    val generator = KeyPairGenerator.getInstance("DH")
    val keyPair1 = generator.genKeyPair()
    val keyPair2 = generator.genKeyPair()
    val agreement = KeyAgreement.getInstance(generator.algorithm)
    agreement.init(keyPair1.private)
    agreement.doPhase(keyPair2.public, true)
    val secretKey1 = agreement.generateSecret("AES")
    agreement.init(keyPair2.private)
    agreement.doPhase(keyPair1.public, true)
    val secretKey2 = agreement.generateSecret("AES")
    println(secretKey1.encoded.toHexString(HexFormat.UpperCase))
    println(secretKey2.encoded.toHexString(HexFormat.UpperCase))
}

RSA算法代码实现

import java.io.FileInputStream
import java.security.KeyPairGenerator
import javax.crypto.Cipher

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val keyAlgorithm = "RSA"
    val cipherAlgorithm = "RSA"
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes().copyOf(245)
    // generate key pair
    val keyGenerator = KeyPairGenerator.getInstance(keyAlgorithm)
    val keyPair = keyGenerator.genKeyPair()
    // encrypt
    val cipher1 = Cipher.getInstance(cipherAlgorithm)
    cipher1.init(Cipher.ENCRYPT_MODE, keyPair.private)
    val encrypted = cipher1.doFinal(origin)
    // decrypt
    val cipher2 = Cipher.getInstance(cipherAlgorithm)
    cipher2.init(Cipher.DECRYPT_MODE, keyPair.public)
    val decrypted = cipher2.doFinal(encrypted)
    println(decrypted.toHexString() == origin.toHexString())
}

DSA算法代码实现

DSA不能用于加密，只能用于签名

用于签名时，必须要配合Signature使用，不能直接使用Cipher

虽然说，签名的实质就是对摘要进行加密，但是Cipher类的定位是数据加密，因此并不支持DSA算法

import java.io.FileInputStream
import java.security.KeyPairGenerator
import java.security.Signature

fun main() {
    val keyAlgorithm = "DSA"
    val signAlgorithm = "SHA256withDSA"
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate key pair
    val keyGenerator = KeyPairGenerator.getInstance(keyAlgorithm)
    val keyPair = keyGenerator.genKeyPair()
    // sign
    val sign = Signature.getInstance(signAlgorithm)
    sign.initSign(keyPair.private)
    sign.update(origin)
    val signature = sign.sign()
    // verify
    val verify = Signature.getInstance(signAlgorithm)
    verify.initVerify(keyPair.public)
    verify.update(origin)
    val result = verify.verify(signature)
    println(result)
}

ECC算法代码实现

ECC用于加密时，需要借助Bouncy Castle来实现

import org.bouncycastle.jce.provider.BouncyCastleProvider
import java.io.FileInputStream
import java.security.KeyPairGenerator
import java.security.Security
import javax.crypto.Cipher

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val provider = "BC"
    val keyAlgorithm = "ECIES"
    val cipherAlgorithm = "ECIES"
    // register bouncy castle provider
    Security.addProvider(BouncyCastleProvider())
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate key pair
    val keyGenerator = KeyPairGenerator.getInstance(keyAlgorithm, provider)
    val keyPair = keyGenerator.genKeyPair()
    // encrypt
    val cipher1 = Cipher.getInstance(cipherAlgorithm, provider)
    cipher1.init(Cipher.ENCRYPT_MODE, keyPair.public)
    val encrypted = cipher1.doFinal(origin)
    // decrypt
    val cipher2 = Cipher.getInstance(cipherAlgorithm, provider)
    cipher2.init(Cipher.DECRYPT_MODE, keyPair.private)
    val decrypted = cipher2.doFinal(encrypted)
    println(decrypted.toHexString() == origin.toHexString())
}

ECC用于签名时，必须要配合Signature使用，不能直接使用Cipher加密摘要

Cipher在进行数据加密时，会对公钥私钥格式进行检测，避免用户乱用

import org.bouncycastle.jce.provider.BouncyCastleProvider
import java.io.FileInputStream
import java.security.KeyPairGenerator
import java.security.Security
import java.security.Signature

fun main() {
    val provider = "BC"
    val keyAlgorithm = "ECIES"
    val signAlgorithm = "SHA256withECDSA"
    // register bouncy castle provider
    Security.addProvider(BouncyCastleProvider())
    // create test data
    val file = "resources/data.txt"
    val origin = FileInputStream(file).readAllBytes()
    // generate key pair
    val keyGenerator = KeyPairGenerator.getInstance(keyAlgorithm, provider)
    val keyPair = keyGenerator.genKeyPair()
    // sign
    val sign = Signature.getInstance(signAlgorithm, provider)
    sign.initSign(keyPair.private)
    sign.update(origin)
    val signature = sign.sign()
    // verify
    val verify = Signature.getInstance(signAlgorithm, provider)
    verify.initVerify(keyPair.public)
    verify.update(origin)
    val result = verify.verify(signature)
    println(result)
}

数字签名算法

数字签名包含两步，第一步是生成摘要，第二步是对摘要进行加密

所以数字签名算法，即是摘要算法和非对称加密算法的组合，常见的组合有

MD5withRSA，SHA256withRSA，SHA256withDSA，SHA256withECDSA

数字签名算法代码实现

数字签名有专门的工具类Signature，不需要我们手动去摘要再加密

上面两节，在介绍DSA和ECC时，已经展示了其用于签名时的使用方式