加解密算法分析
日常开发中,无论你是使用什么语言,都应该遇到过使用加解密的使用场景,比如接口数据需要加密传给前端保证数据传输的安全;HTTPS使用证书的方式首先进行非对称加密,将客户端的私匙传递给服务端,然后双方后面的通信都使用该私匙进行对称加密传输;使用MD5进行文件一致性校验,等等很多的场景都使用到了加解密技术。
很多时候我们对于什么时候要使用什么样的加解密方式是很懵的。因为可用的加解密方案实在是太多,大家对加解密技术的类型可能不是很清楚,今天这篇文章就来梳理一下目前主流的加解密技术,本篇文档只针对算法做科普性说明,不涉及具体算法分析。日常使用的加解密大致可以分为以下四类:
- 散列函数(也称信息摘要)算法
- 对称加密算法
- 非对称加密算法
- 组合加密技术
1. 散列函数算法
听名字似乎不是一种加密算法,类似于给一个对象计算出hash值。所以这种算法一般用于数据特征提取。常用的散列函数包括:MD5、SHA1、SHA2(包括SHA128、SHA256等)散列函数的应用很广,散列函数有个特点,它是一种单向加密算法,只能加密、无法解密。
1.1 MD5
先来看MD5算法,MD5算法是广为使用的数据特征提取算法,最常见的就是我们在下载一些软件,网站都会提供MD5值给你进行校验,你可以通过MD5值是否一致来检查当前文件是否被别人篡改。MD5算法具有以下特点:
- 任意长度的数据得到的MD5值长度都是相等的;
- 对原数据进行任一点修改,得到的MD5值就会有很大的变化;
- 散列函数的不可逆性,即已知原数据,无法通过特征值反向获取原数据。(需要说明的是2004年的国际密码讨论年会(CRYPTO)尾声,王小云及其研究同事展示了MD5、SHA-0及其他相关杂凑函数的杂凑冲撞。也就是说,她找出了第一个 两个值不同,但 MD5 值相同的碰撞的例子。这个应该不能称之为破解)
1.2 MD5用途:
- 防篡改。上面说过用于文件完整性校验。
- 用于不想让别人看到明文的地方。比如用户密码入库,可以将用户密码使用MD5加密存储,下次用户输入密码登录只用将他的输入进行MD5加密与数据库的值判断是否一致即可,这样就有效防止密码泄露的风险。
- 用于文件秒传。比如百度云的文件秒传功能可以用这种方式来实现。在你点击上传的时候,前端同学会先计算文件的MD5值然后与服务端比对是否存在,如果有就会告诉你文件上传成功,即完成所谓的秒传。
在JDK中提供了MD5的实现:java.security包中有个类MessageDigest,MessageDigest 类为应用程序提供信息摘要算法的功能,如 MD5 或 SHA 算法。信息摘要是安全的单向哈希函数,它接收任意大小的数据,输出固定长度的哈希值。
MessageDigest 对象使用getInstance函数初始化,该对象通过使用 update 方法处理数据。任何时候都可以调用 reset 方法重置摘要。一旦所有需要更新的数据都已经被更新了,应该调用 digest 方法之一完成哈希计算。
对于给定数量的更新数据,digest 方法只能被调用一次。digest 被调用后,MessageDigest 对象被重新设置成其初始状态。
下面的例子展示了使用JDK自带的MessageDigest类使用MD5算法。同时也展示了如果使用了update方法后没有调用digest方法,则会累计当前所有的update中的值在下一次调用digest方法的时候一并输出:
package other; import java.security.MessageDigest; /** * @author: rickiyang * @date: 2019/9/13 * @description: */ public class MD5Test { static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; public static void main(String[] args) { try { //申明使用MD5算法 MessageDigest md5 = MessageDigest.getInstance("MD5"); md5.update("a".getBytes());// System.out.println("md5(a)=" + byte2str(md5.digest())); md5.update("a".getBytes()); md5.update("bc".getBytes()); System.out.println("md5(abc)=" + byte2str(md5.digest())); //你会发现上面的md5值与下面的一样 md5.update("abc".getBytes()); System.out.println("md5(abc)=" + byte2str(md5.digest())); } catch (Exception e) { e.printStackTrace(); } } /** * 将字节数组转换成十六进制字符串 * * @param bytes * @return */ private static String byte2str(byte[] bytes) { int len = bytes.length; StringBuffer result = new StringBuffer(); for (int i = 0; i < len; i++) { byte byte0 = bytes[i]; result.append(hex[byte0 >>> 4 & 0xf]); result.append(hex[byte0 & 0xf]); } return result.toString(); } }
输出:
md5(a)=0CC175B9C0F1B6A831C399E269772661
md5(abc)=900150983CD24FB0D6963F7D28E17F72
md5(abc)=900150983CD24FB0D6963F7D28E17F72
1.3 SHA系列算法
Secure Hash Algorithm,是一种与MD5同源的数据加密算法。SHA算法能计算出一个数位信息所对应到的,长度固定的字串,又称信息摘要。而且如果输入信息有任何的不同,输出的对应摘要不同的机率非常高。因此SHA算法也是FIPS所认证的五种安全杂凑算法之一。原因有两点:一是由信息摘要反推原输入信息,从计算理论上来说是极为困难的;二是,想要找到两组不同的输入信息发生信息摘要碰撞的几率,从计算理论上来说是非常小的。任何对输入信息的变动,都有很高的几率导致的信息摘要大相径庭。
SHA实际上是一系列算法的统称,分别包括:SHA-1、SHA-224、SHA-256、SHA-384以及SHA-512。后面4中统称为SHA-2,事实上SHA-224是SHA-256的缩减版,SHA-384是SHA-512的缩减版。各中SHA算法的数据比较如下表,其中的长度单位均为位:
SHA-1算法输入报文的最大长度不超过264位,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。
上面提到的MessageDigest类同时也支持SHA系列算法,使用方式与MD5一样,注意SHA不同的类型:
MessageDigest md = MessageDigest.getInstance("SHA");
MessageDigest md = MessageDigest.getInstance("SHA-224");
MessageDigest md = MessageDigest.getInstance("SHA-384");
2. 对称加密算法
所谓的对称加密,意味着加密者和解密者需要同时持有一份相同的密匙,加密者用密匙加密,解密者用密匙解密即可。
常用的对称加密算法包括DES算法、AES算法等。 由于对称加密需要一个秘钥,而秘钥在加密者与解密者之间传输又很难保证安全性,所以目前用对称加密算法的话主要是用在加密者解密者相同,或者加密者解密者相对固定的场景。
对称算法又可分为两类:
第一种是一次只对明文中的单个位(有时对字节)运算的算法称为序列算法或序列密码;
另一种算法是对明文的一组位进行运算,这些位组称为分组,相应的算法称为分组算法或分组密码。现代计算机密码算法的典型分组长度为64位――这个长度既考虑到分析破译密码的难度,又考虑到使用的方便性。
2.1 BASE64算法
我们很熟悉的BASE64算法就是一个没有秘密的对称加密算法。因为他的加密解密算法都是公开的,所以加密数据是没有任何秘密可言,典型的防菜鸟不防程序员的算法。
BASE64算法作用:
用于简单的数据加密传输;
- 用于数据传输过程中的转码,解决中文问题和特殊符号在网络传输中的乱码现象。
- 网络传输过程中如果双方使用的编解码字符集方式不一致,对于中文可能会出现乱码;与此类似,网络上传输的字符并不全是可打印的字符,比如二进制文件、图片等。Base64的出现就是为了解决此问题,它是基于64个可打印的字符来表示二进制的数据的一种方法。
BASE64原理
BASE64的原理比较简单,每当我们使用BASE64时都会先定义一个类似这样的数组:
['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']
上面就是BASE64的索引表,字符选用了"A-Z、a-z、0-9、+、/" 64个可打印字符,这是标准的BASE64协议规定。在日常使用中我们还会看到“=”或“==”号出现在BASE64的编码结果中,“=”在此是作为填充字符出现。
JDK提供了BASE64的实现:BASE64Encoder,我们可以直接使用:
//使用base64加密 BASE64Encoder encoder = new BASE64Encoder(); String encrypt = encoder.encode(str.getBytes()); //使用base64解密 BASE64Decoder decoder = new BASE64Decoder(); String decrypt = new String(decoder.decodeBuffer(encryptStr));
2.2 DES
DES (Data Encryption Standard),在很长时间内,许多人心目中“密码生成”与DES一直是个同义词。
DES是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。它的密钥长度是56位(因为每个第8 位都用作奇偶校验),密钥可以是任意的56位的数,而且可以任意时候改变。
DES加密过程大致如下:
- 首先需要从用户处获取一个64位长的密码口令,然后通过等分、移位、选取和迭代形成一套16个加密密钥,分别供每一轮运算中使用;
- 然后将64位的明文分组M进行操作,M经过一个初始置换IP,置换成m0。将m0明文分成左半部分和右半部分m0 = (L0,R0),各32位长。然后进行16轮完全相同的运算(迭代),这些运算被称为函数f,在每一轮运算过程中数据与相应的密钥结合;
- 在每一轮迭代中密钥位移位,然后再从密钥的56位中选出48位。通过一个扩展置换将数据的右半部分扩展成48位,并通过一个异或操作替代成新的48位数据,再将其压缩置换成32位。这四步运算构成了函数f。然后,通过另一个异或运算,函数f的输出与左半部分结合,其结果成为新的右半部分,原来的右半部分成为新的左半部分。将该操作重复16次;
- 经过16轮迭代后,左,右半部分合在一起经过一个末置换(数据整理),这样就完成了加密过程。
对于DES解密的过程大家猛然一想应该是使用跟加密过程相反的算法,事实上解密和加密使用的是一样的算法,有区别的地方在于加密和解密在使用密匙的时候次序是相反的。比如加密的时候是K0,K1,K2......K15,那么解密使用密匙的次序就是倒过来的。之所以能用相同的算法去解密,这跟DES特意设计的加密算法有关,感兴趣的同学可以深入分析。
2.3 AES
高级加密标准(AES,Advanced Encryption Standard),与DES一样,使用AES加密函数和密匙来对明文进行加密,区别就是使用的加密函数不同。
上面说过DES的密钥长度是56比特,因此算法的理论安全强度是2^56。但以目前计算机硬件的制作水准和升级情况,破解DES可能只是山脉问题,最终NIST(美国国家标准技术研究所(National Institute of Standards and Technology))选择了分组长度为128位的Rijndael算法作为AES算法。
AES为分组密码,分组密码也就是把明文分成一组一组的,每组长度相等,每次加密一组数据,直到加密完整个明文。在AES标准规范中,分组长度只能是128位,也就是说,每个分组为16个字节(每个字节8位)。密钥的长度可以使用128位、192位或256位。密钥的长度不同,推荐加密轮数也不同,如下表所示:
3. 非对称加密
非对称加密算法的特点是,秘钥一次会生成一对,其中一份秘钥由自己保存,不能公开出去,称为“私钥”,另外一份是可以公开出去的,称为“公钥”。
将原文用公钥进行加密,得到的密文只有用对应私钥才可以解密得到原文;
将原文用私钥加密得到的密文,也只有用对应的公钥才能解密得到原文;
因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。
与对称加密算法的对比
- 优点:其安全性更好,对称加密的通信双方使用相同的秘钥,如果一方的秘钥遭泄露,那么整个通信就会被破解。而非对称加密使用一对秘钥,一个用来加密,一个用来解密,而且公钥是公开的,秘钥是自己保存的,不需要像对称加密那样在通信之前要先同步秘钥。
- 缺点:非对称加密的缺点是加密和解密花费时间长、速度慢,只适合对少量数据进行加密。
在非对称加密中使用的主要算法有:RSA、Elgamal、ESA、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)等。不同算法的实现机制不同。
非对称加密工作原理
下面我们就看一下非对称加密的工作原理。
- 乙方生成一对密钥(公钥和私钥)并将公钥向其它方公开。
- 得到该公钥的甲方使用该密钥对机密信息进行加密后再发送给乙方。
- 乙方再用自己保存的另一把专用密钥(私钥)对加密后的信息进行解密。乙方只能用其专用密钥(私钥)解密由对应的公钥加密后的信息。
- 在传输过程中,即使攻击者截获了传输的密文,并得到了乙的公钥,也无法破解密文,因为只有乙的私钥才能解密密文。同样,如果乙要回复加密信息给甲,那么需要甲先公布甲的公钥给乙用于加密,甲自己保存甲的私钥用于解密。
非对称加密鼻祖:RSA
RSA算法基于一个十分简单的数论事实:将两个大质数(素数)相乘十分容易,但是想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。比如:取两个简单的质数:67,73,得到两者乘积很简单4891;但是要想对4891进行因式分解,其工作量成几何增加。
应用场景:
HTTPS请求的SSL层。
在JDK中也提供了RSA的实现,下面给出示例:
/** * 创建密匙对 * * @return */ private KeyPair genKeyPair() { //创建 RSA Key 的生产者。 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); //利用用户密码作为随机数初始化出 1024 比特 Key 的生产者。 //SecureRandom 是生成安全随机数序列,password.getBytes() 是种子,只要种子相同,序列就一样。 keyPairGen.initialize(1024, new SecureRandom("password".getBytes())); //创建密钥对 return keyPairGen.generateKeyPair(); } /** * 生成公匙 * * @return */ public PublicKey genPublicKey() { try { //创建密钥对 KeyPair keyPair = genKeyPair(); //生成公钥 PublicKey publicKey = keyPair.getPublic(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey.getEncoded()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); publicKey = keyFactory.generatePublic(keySpec); return publicKey; } catch (Exception e) { e.printStackTrace(); } return null; } /** * 生成私匙 * * @return */ public PrivateKey genPrivateKey() { try { //创建密钥对 KeyPair keyPair = genKeyPair(); //生成私匙 PrivateKey privateKey = keyPair.getPrivate(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(privateKey.getEncoded()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return keyFactory.generatePrivate(keySpec); } catch (Exception e) { e.printStackTrace(); } return null; } /** * 公钥加密 * * @param data * @param publicKey * @return * @throws Exception */ public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception { X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey.getBytes()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); Key publicK = keyFactory.generatePublic(x509KeySpec); // 对数据加密 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.ENCRYPT_MODE, publicK); int inputLen = data.length; ByteArrayOutputStream out = new ByteArrayOutputStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段加密 while (inputLen - offSet > 0) { if (inputLen - offSet > 117) { cache = cipher.doFinal(data, offSet, 117); } else { cache = cipher.doFinal(data, offSet, inputLen - offSet); } out.write(cache, 0, cache.length); i++; offSet = i * 117; } byte[] encryptedData = out.toByteArray(); out.close(); return encryptedData; } /** * 私钥解密 * * @param encryptedData * @param privateKey * @return * @throws Exception */ public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception { PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey.getBytes()); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, privateK); int inputLen = encryptedData.length; ByteArrayOutputStream out = new ByteArrayOutputStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段解密 while (inputLen - offSet > 0) { if (inputLen - offSet > 118) { cache = cipher.doFinal(encryptedData, offSet, 118); } else { cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); } out.write(cache, 0, cache.length); i++; offSet = i * 118; } byte[] decryptedData = out.toByteArray(); out.close(); return decryptedData; } /** * 私钥加密 * * @param data * @param privateKey * @return * @throws Exception */ public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception { PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(publicKey.getBytes()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.ENCRYPT_MODE, privateK); int inputLen = data.length; ByteArrayOutputStream out = new ByteArrayOutputStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段加密 while (inputLen - offSet > 0) { if (inputLen - offSet > 117) { cache = cipher.doFinal(data, offSet, 117); } else { cache = cipher.doFinal(data, offSet, inputLen - offSet); } out.write(cache, 0, cache.length); i++; offSet = i * 117; } byte[] encryptedData = out.toByteArray(); out.close(); return encryptedData; } /** * 公钥解密 * * @param encryptedData * @param publicKey * @return * @throws Exception */ public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception { X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey.getBytes()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); Key publicK = keyFactory.generatePublic(x509KeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, publicK); int inputLen = encryptedData.length; ByteArrayOutputStream out = new ByteArrayOutputStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段解密 while (inputLen - offSet > 0) { if (inputLen - offSet > 118) { cache = cipher.doFinal(encryptedData, offSet, 118); } else { cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); } out.write(cache, 0, cache.length); i++; offSet = i * 118; } byte[] decryptedData = out.toByteArray(); out.close(); return decryptedData; }
4. 组合加密
上面介绍的3种加密技术,每一种都有自己的特点,比如散列技术用于特征值提取,对称加密速度虽快但是有私匙泄露的危险,非对称加密虽然安全但是速度却慢。基于这些情况,现在的加密技术更加趋向于将这些加密的方案组合起来使用,基于此来研发新的加密算法。
MAC(Message Authentication Code,消息认证码算法)是含有密钥散列函数算法,兼容了MD和SHA算法的特性,并在此基础上加上了密钥。因此MAC算法也经常被称作HMAC算法。MAC(Message Authentication Code,消息认证码算法)是含有密钥散列函数算法,HMAC加密可以理解为加盐的散列算法,此处的“盐”就相当于HMAC算法的秘钥。
HMAC算法的实现过程需要一个加密用的散列函数(表示为H)和一个密钥。
经过MAC算法得到的摘要值也可以使用十六进制编码表示,其摘要值得长度与实现算法的摘要值长度相同。例如 HmacSHA算法得到的摘要长度就是SHA1算法得到的摘要长度,都是160位二进制数,换算成十六进制的编码为40位。
MAC算法的实现:
过程如下:
- 在密钥key后面添加0来创建一个长为B(64字节)的字符串(str);
- 将上一步生成的字符串(str) 与ipad(0x36)做异或运算,形成结果字符串(istr);
- 将数据流data附加到第二步的结果字符串(istr)的末尾;
- 做md5运算于第三步生成的数据流(istr);
- 将第一步生成的字符串(str) 与opad(0x5c)做异或运算,形成结果字符串(ostr),再将第四步的结果(istr) 附加到第五步的结果字符串(ostr)的末尾做md5运算于第6步生成的数据流(ostr),最终输出结果(out)
注意:如果第一步中,key的长度klen大于64字节,则先进行md5运算,使其长度klen = 16字节。
JDK中的实现:
public static void jdkHmacMD5() { try { // 初始化KeyGenerator KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5"); // 产生密钥 SecretKey secretKey = keyGenerator.generateKey(); // 获取密钥 byte[] key = secretKey.getEncoded(); // byte[] key = Hex.decodeHex(new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e'}); // 还原密钥 SecretKey restoreSecretKey = new SecretKeySpec(key, "HmacMD5"); // 实例化MAC Mac mac = Mac.getInstance(restoreSecretKey.getAlgorithm()); // 初始化MAC mac.init(restoreSecretKey); // 执行摘要 byte[] hmacMD5Bytes = mac.doFinal("data".getBytes()); System.out.println("jdk hmacMD5:" + new String(hmacMD5Bytes)); } catch (Exception e) { e.printStackTrace(); } }
以上就是详细分析JAVA加解密算法的详细内容,更多关于JAVA加解密算法的资料请关注易盾网络其它相关文章!