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

文章目录

- - - - Java加密库
      - 摘要算法
      - MD5代码实现
      - SHA256代码实现
      - HmacMD5代码实现
      - CRC32代码实现
      - 对称加密算法
      - 查看JDK支持的算法
      - Base64代码实现
      - DES代码实现
      - DESede代码实现
      - AES代码实现
      - RC代码实现
      - IDEA代码实现
      - PBE代码实现
      - 非对称加密算法
      - DH秘钥交换算法数学原理
      - DH算法代码实现
      - RSA算法代码实现
      - DSA算法代码实现
      - ECC算法代码实现
      - 数字签名算法
      - 数字签名算法代码实现

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