您的位置：360文档中心› Java非对称加密(三)-代码及说明

Java非对称加密(三)-代码及说明

合集下载

使用Java实现安全性加密与解密

使用Java实现安全性加密与解密

使用Java实现安全性加密与解密在当今信息时代，数据的安全性越来越受到重视。

无论是个人的隐私信息还是企业的商业机密，都需要得到有效的保护。

而加密与解密技术就是一种常用的保护数据安全的手段。

本文将介绍如何使用Java语言实现安全性加密与解密。

1. 加密与解密的基本概念加密是将明文转换为密文的过程，而解密则是将密文转换回明文的过程。

加密算法通常使用一个密钥，密钥用于控制加密过程的转换规则，只有拥有正确的密钥才能进行解密。

常见的加密算法有对称加密算法和非对称加密算法。

对称加密算法使用相同的密钥进行加密和解密，速度较快，但密钥的传输和管理相对困难。

非对称加密算法使用一对密钥，公钥用于加密，私钥用于解密，安全性较高，但速度较慢。

2. 使用Java实现对称加密Java提供了多种对称加密算法的实现，如DES、AES等。

下面以AES算法为例，介绍如何使用Java实现对称加密。

首先，需要导入Java加密扩展（JCE）的包。

在Java 8及以上版本中，JCE已经被默认包含在JDK中，无需额外导入。

接下来，可以使用以下代码进行AES加密：```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESUtil {private static final String ALGORITHM = "AES";public static String encrypt(String plainText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());return Base64.getEncoder().encodeToString(encryptedBytes);}public static String decrypt(String encryptedText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);byte[] encryptedBytes = Base64.getDecoder().decode(encryptedText);byte[] decryptedBytes = cipher.doFinal(encryptedBytes);return new String(decryptedBytes);}}```以上代码中，`encrypt`方法用于对明文进行加密，`decrypt`方法用于对密文进行解密。

des加密算法java代码

des加密算法java代码

des加密算法java代码1、DES加密算法Java实现（1）导入所需要的包：import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;（2）定义加密算法：public class DesEncrypter {Cipher ecipher;Cipher dcipher;public DesEncrypter(String passPhrase) {try {// Create the keyDESKeySpec keySpec = newDESKeySpec(passPhrase.getBytes('UTF8'));SecretKeyFactory keyFactory =SecretKeyFactory.getInstance('DES');SecretKey key = keyFactory.generateSecret(keySpec); // Create the cipherecipher = Cipher.getInstance('DES');dcipher = Cipher.getInstance('DES');// Initialize the cipher for encryptionecipher.init(Cipher.ENCRYPT_MODE, key);// Initialize the same cipher for decryption dcipher.init(Cipher.DECRYPT_MODE, key);} catch (Exception e) {}}（3）定义加密函数：public String encrypt(String str) {try {// Encode the string into bytes using utf-8 byte[] utf8 = str.getBytes('UTF8');// Encryptbyte[] enc = ecipher.doFinal(utf8);// Encode bytes to base64 to get a stringreturn new sun.misc.BASE64Encoder().encode(enc);} catch (Exception e) {}return null;}（4）定义解密函数：// Decryptpublic String decrypt(String str) {try {// Decode base64 to get bytesbyte[] dec = newsun.misc.BASE64Decoder().decodeBuffer(str);// Decryptbyte[] utf8 = dcipher.doFinal(dec);// Decode using utf-8return new String(utf8, 'UTF8');} catch (Exception e) {}return null;}}（5）定义测试类，测试加密解之密是否正确：public class TestDes {public static void main(String[] args) {try {// Create encrypter/decrypter classDesEncrypter encrypter = new DesEncrypter('your key');// EncryptString encrypted = encrypter.encrypt('Don't tell anybody!');// DecryptString decrypted = encrypter.decrypt(encrypted);// Print out valuesSystem.out.println('Encrypted: ' + encrypted);System.out.println('Decrypted: ' + decrypted);} catch (Exception e) {}}}。

Java使用Cipher类实现加密，包括DES，DES3，AES和RSA加密

Java使用Cipher类实现加密，包括DES，DES3，AES和RSA加密

Java使⽤Cipher类实现加密，包括DES，DES3，AES和RSA加密⼀、先看⼀个简单加密，解密实现1.1 加密/*** content: 加密内容* slatKey: 加密的盐，16位字符串* vectorKey: 加密的向量，16位字符串*/public String encrypt(String content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);byte[] encrypted = cipher.doFinal(content.getBytes());return Base64.encodeBase64String(encrypted);}1.2 解密/*** content: 解密内容(base64编码格式)* slatKey: 加密时使⽤的盐，16位字符串* vectorKey: 加密时使⽤的向量，16位字符串*/public String decrypt(String base64Content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);byte[] content = Base64.decodeBase64(base64Content);byte[] encrypted = cipher.doFinal(content);return new String(encrypted);}1.3 代码解释上⾯简单实现了AES("AES/CBC/PKCS5Padding")的加密和解密。

对称加密的概述及简单实现

对称加密的概述及简单实现

对称加密的概述及简单实现⼀.什么是对称加密常见的加密⽅式分为三种：1.正向加密：如MD5，加密后密⽂固定，⽬前还没有办法破解，但是能够通过数据库撞库有⼀定概率找到，不过现在⼀般⽤这种⽅式加密都会加上盐值。

2.对称加密：通过⼀个固定的对称密钥，对需要传输的数据进⾏加密，速度快，但是安全性不⾼，主要⽤于企业级内部系统中数据传输。

3.⾮对称加密：N把公钥，⼀把私钥，私钥存放在服务器⼀⽅保管，公钥可以放在任意⼀个客户端，客户端向服务器请求的密⽂只有拿到了秘钥的服务器⼀端可以解密。

本⽂主要介绍对称加密。

对称加密是⼀种使⽤单钥密码系统的加密⽅法，同⼀个密钥可以同时⽤作信息的加密和解密。

由于其速度快，对称性加密通常在消息发送⽅需要加密⼤量数据时使⽤。

对称加密也称为密钥加密。

所谓对称，就是采⽤这种加密⽅法的双⽅使⽤⽅式⽤同样的密钥进⾏加密和解密。

密钥是控制加密和解密过程的指令。

算法是⼀组规则，规定如何进⾏加密和解密。

因此加密的安全性不仅取决于加密算法本⾝，密钥管理的安全性更是重要。

因为加密和解密都使⽤同⼀个密钥，如何把密钥安全地传递到解密者⼿上就成了必须要解决的问题。

⼆.什么是随机盐值wiki百科对盐值的介绍如下：盐（Salt），在密码学中，是指通过在密码任意固定位置插⼊特定的字符串，让散列后的结果和使⽤原始密码的散列结果不相符，这种过程称之为“加盐”。

安全因素通常情况下，当字段经过散列处理（如），会⽣成⼀段散列值，⽽散列后的值⼀般是⽆法通过特定算法得到原始字段的。

但是某些情况，⽐如⼀个⼤型的，通过在表中搜索该MD5值，很有可能在极短的时间内找到该散列值对应的真实字段内容。

加盐后的散列值，可以极⼤的降低由于⽤户数据被盗⽽带来的密码泄漏风险，即使通过彩虹表寻找到了散列后的数值所对应的原始内容，但是由于经过了加盐，插⼊的字符串扰乱了真正的密码，使得获得真实密码的概率⼤⼤降低。

实现原理：⽐如⽤户使⽤“abcd”这个字符串作为密码，经过MD5散列后得到了：E2FC714C4727EE9395F324CD2E7F331F但是由于⽤户密码较简单，短密码的散列结果很容易通过撞库破解。

对称加密和非对称加密

对称加密和非对称加密

对称加密和⾮对称加密⼀、对称加密算法对称加密采⽤了对称密码编码技术，它的特点是⽂件加密和解密使⽤相同的密钥加密也就是密钥也可以⽤作解密密钥，这种⽅法在密码学中叫做对称加密算法，对称加密算法使⽤起来简单快捷，密钥较短，且破译困难，除了数据加密标准（DES），另⼀个对称密钥加密系统是国际数据加密算法（IDEA），它⽐DES的加密性好，⽽且对计算机功能要求也没有那么⾼对称加密算法在电⼦商务交易过程中存在⼏个问题：1、要求提供⼀条安全的渠道使通讯双⽅在⾸次通讯时协商⼀个共同的密钥。

直接的⾯对⾯协商可能是不现实⽽且难于实施的，所以双⽅可能需要借助于邮件和电话等其它相对不够安全的⼿段来进⾏协商；2、密钥的数⽬难于管理。

因为对于每⼀个合作者都需要使⽤不同的密钥，很难适应开放社会中⼤量的信息交流；3、对称加密算法⼀般不能提供信息完整性的鉴别。

它⽆法验证发送者和接受者的⾝份；4、对称密钥的管理和分发⼯作是⼀件具有潜在危险的和烦琐的过程。

对称加密是基于共同保守秘密来实现的，采⽤对称加密技术的贸易双⽅必须保证采⽤的是相同的密钥，保证彼此密钥的交换是安全可靠的，同时还要设定防⽌密钥泄密和更改密钥的程序。

假设两个⽤户需要使⽤对称加密⽅法加密然后交换数据，则⽤户最少需要2个密钥并交换使⽤，如果企业内⽤户有n个，则整个企业共需要n×(n-1) 个密钥，密钥的⽣成和分发将成为企业信息部门的恶梦。

常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES常⽤算法介绍：（1）DES(Data Encryption Standard，数据加密算法) DES是最基本的对称加密算法，也是使⽤频率最⾼的⼀种算法，加密密钥与解密密钥相同。

DES出⾝⽐较好，出⾃IBM之⼿，后被美国军⽅采纳，之后便⼴泛流传，但是近些年使⽤越来越少，因为DES使⽤56位密钥，以现代计算能⼒，24⼩时内即可被破解。

虽然如此，在某些简单应⽤中，我们还是可以使⽤DES加密算法。

javaRSAUtils加密工具类操作

javaRSAUtils加密工具类操作

javaRSAUtils加密⼯具类操作1.RSA加密算法是⼀种⾮对称加密算法。

在公开密钥加密和电⼦商业中RSA被⼴泛使⽤。

RSA公开密钥密码体制。

所谓的公开密钥密码体制就是使⽤不同的加密密钥与解密密钥，是⼀种“由已知加密密钥推导出解密密钥在计算上是不可⾏的”密码体制。

在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，⽽解密密钥（即秘密密钥）SK是需要保密的。

加密算法E和解密算法D也都是公开的。

虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。

2.本⼯具类涉及到BASE64编码，所以先展⽰出BASE64Utils：package mon.util;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.security.MessageDigest;/*** BASE64的加解密* @author Neo* @date 2018-4-15 22:21:51**/@SuppressWarnings("restriction")public class Base64Utils {public static final String KEY_SHA = "SHA";public static final String KEY_MD5 = "MD5";/*** BASE64解密** @param key* @return* @throws Exception*/public static byte[] decryptBASE64(String key) throws Exception {return (new BASE64Decoder()).decodeBuffer(key);}/*** BASE64加密** @param key* @return* @throws Exception*/public static String encryptBASE64(byte[] key) throws Exception {return (new BASE64Encoder()).encodeBuffer(key);}/*** MD5加密** @param data* @return* @throws Exception*/public static byte[] encryptMD5(byte[] data) throws Exception {MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);md5.update(data);return md5.digest();}/*** SHA加密** @param data* @return* @throws Exception*/public static byte[] encryptSHA(byte[] data) throws Exception {MessageDigest sha = MessageDigest.getInstance(KEY_SHA);sha.update(data);return sha.digest();}}3.然后我们展⽰RSAUtils：package mon.util;import javax.crypto.Cipher;import java.security.*;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;/*** RSA安全编码组件** @version 1.0* @desc 公钥和私钥存放在properties⽂件的时候每⾏的末尾加上“\r\n\” <br/>* “\r\n” 起到换⾏的作⽤,最后的“\”在properties在⾥表⽰连接** @author Neo* @date 2018-4-15 22:23:19* @since 1.0*/public class RSAUtils extends Base64Utils {public static final String KEY_ALGORITHM = "RSA";public static final String SIGNATURE_ALGORITHM = "MD5withRSA";private static final String PUBLIC_KEY = "RSAPublicKey";private static final String PRIVATE_KEY = "RSAPrivateKey";/*** ⽤私钥对信息⽣成数字签名** @param data 加密数据* @param privateKey 私钥* @return* @throws Exception*/public static String sign(String data, String privateKey) throws Exception {return sign(data.getBytes(), privateKey);}/*** ⽤私钥对信息⽣成数字签名** @param data 加密数据* @param privateKey 私钥* @return* @throws Exception*/public static String sign(byte[] data, String privateKey) throws Exception {// 解密由base64编码的私钥byte[] keyBytes = decryptBASE64(privateKey);// 构造PKCS8EncodedKeySpec对象PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); // KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取私钥匙对象PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);// ⽤私钥对信息⽣成数字签名Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initSign(priKey);signature.update(data);return encryptBASE64(signature.sign());/*** 校验数字签名** @param data 加密数据* @param publicKey 公钥* @param sign 数字签名* @return 校验成功返回true 失败返回false* @throws Exception*/public static boolean verify(String data, String publicKey, String sign) throws Exception { return verify(data.getBytes(), publicKey, sign);}/*** 校验数字签名** @param data 加密数据* @param publicKey 公钥* @param sign 数字签名* @return 校验成功返回true 失败返回false* @throws Exception*/public static boolean verify(byte[] data, String publicKey, String sign) throws Exception { // 解密由base64编码的公钥byte[] keyBytes = decryptBASE64(publicKey);// 构造X509EncodedKeySpec对象X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);// KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取公钥匙对象PublicKey pubKey = keyFactory.generatePublic(keySpec);Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initVerify(pubKey);signature.update(data);// 验证签名是否正常return signature.verify(decryptBASE64(sign));}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static String decryptByPrivateKey(String data, String key) throws Exception {return new String(decryptByPrivateKey(Base64Utils.decryptBASE64(data), key));}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {// 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static String decryptByPublicKey(String data, String key) throws Exception { return new String(decryptByPublicKey(Base64Utils.decryptBASE64(data), key)); }/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception { // 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, publicKey);return cipher.doFinal(data);}/*** 加密<br>* ⽤公钥加密** @param data* @param key* @return* @throws Exception*/public static String encryptByPublicKey(String data, String key) throws Exception { return Base64Utils.encryptBASE64(encryptByPublicKey(data.getBytes(), key)); }/*** 加密<br>* ⽤公钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception { // 对公钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, publicKey);return cipher.doFinal(data);}/*** 加密<br>* ⽤私钥加密** @param data* @param key* @return* @throws Exception*/public static String encryptByPrivateKey(String data, String key) throws Exception { return Base64Utils.encryptBASE64(encryptByPrivateKey(data.getBytes(), key)); }/*** 加密<br>* ⽤私钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception { // 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 取得私钥** @param keyMap* @return* @throws Exception*/public static String getPrivateKey(Map<String, Object> keyMap) throws Exception { Key key = (Key) keyMap.get(PRIVATE_KEY);return encryptBASE64(key.getEncoded());}/*** 取得公钥** @param keyMap* @return* @throws Exception*/public static String getPublicKey(Map<String, Object> keyMap) throws Exception {Key key = (Key) keyMap.get(PUBLIC_KEY);return encryptBASE64(key.getEncoded());}/*** 初始化密钥** @return* @throws Exception*/public static Map<String, Object> initKey() throws Exception {KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM); keyPairGen.initialize(1024);KeyPair keyPair = keyPairGen.generateKeyPair();// 公钥RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();// 私钥RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();Map<String, Object> keyMap = new HashMap<String, Object>(2);keyMap.put(PUBLIC_KEY, publicKey);keyMap.put(PRIVATE_KEY, privateKey);return keyMap;}public static void main(String[] args) {try {Map<String, Object> map = RSAUtils.initKey();String publicKey = RSAUtils.getPublicKey(map);String privateKey = RSAUtils.getPrivateKey(map);System.out.println("公钥：" + publicKey);System.out.println("私钥：" + privateKey);String data = "Java是世界上最好的编程语⾔";String encryptData = RSAUtils.encryptByPublicKey(data, publicKey);System.out.println("加密后：" + encryptData);String decryptData = RSAUtils.decryptByPrivateKey(encryptData, privateKey);System.out.println("解密后：" + decryptData);} catch (Exception e) {e.printStackTrace();}}}4.最后展⽰测试结果：补充知识：java使⽤RSA⽣成公钥和私钥，并进⾏加解密废话不多说，上代码：import javax.crypto.Cipher;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.SecureRandom;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;/*** Java RSA 加密⼯具类*/public class RSAUtils {/*** 密钥长度于原⽂长度对应以及越长速度越慢*/private final static int KEY_SIZE = 1024;/*** ⽤于封装随机产⽣的公钥与私钥*/private static Map<Integer, String> keyMap = new HashMap<Integer, String>();/*** 随机⽣成密钥对* @throws Exception*/public static void genKeyPair() throws Exception {// KeyPairGenerator类⽤于⽣成公钥和私钥对，基于RSA算法⽣成对象KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");// 初始化密钥对⽣成器keyPairGen.initialize(KEY_SIZE, new SecureRandom());// ⽣成⼀个密钥对，保存在keyPair中KeyPair keyPair = keyPairGen.generateKeyPair();// 得到私钥RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();// 得到公钥RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();String publicKeyString = encryptBASE64(publicKey.getEncoded());// 得到私钥字符串String privateKeyString = encryptBASE64(privateKey.getEncoded());// 将公钥和私钥保存到Map//0表⽰公钥keyMap.put(0, publicKeyString);//1表⽰私钥keyMap.put(1, privateKeyString);}//编码返回字符串public static String encryptBASE64(byte[] key) throws Exception {return (new BASE64Encoder()).encodeBuffer(key);}//解码返回bytepublic static byte[] decryptBASE64(String key) throws Exception {return (new BASE64Decoder()).decodeBuffer(key);}/*** RSA公钥加密** @param str 加密字符串* @param publicKey 公钥* @return 密⽂* @throws Exception 加密过程中的异常信息*/public static String encrypt(String str, String publicKey) throws Exception {//base64编码的公钥byte[] decoded = decryptBASE64(publicKey);RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded)); //RSA加密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, pubKey);String outStr = encryptBASE64(cipher.doFinal(str.getBytes("UTF-8")));return outStr;}/*** RSA私钥解密** @param str 加密字符串* @param privateKey 私钥* @return 明⽂* @throws Exception 解密过程中的异常信息*/public static String decrypt(String str, String privateKey) throws Exception {//64位解码加密后的字符串byte[] inputByte = decryptBASE64(str);//base64编码的私钥byte[] decoded = decryptBASE64(privateKey);RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));//RSA解密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.DECRYPT_MODE, priKey);String outStr = new String(cipher.doFinal(inputByte));return outStr;}public static void main(String[] args) throws Exception {long temp = System.currentTimeMillis();//⽣成公钥和私钥genKeyPair();//加密字符串System.out.println("公钥:" + keyMap.get(0));System.out.println("私钥:" + keyMap.get(1));System.out.println("⽣成密钥消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");String message = "RSA测试aaa";System.out.println("原⽂:" + message);temp = System.currentTimeMillis();String messageEn = encrypt(message, keyMap.get(0));System.out.println("密⽂:" + messageEn);System.out.println("加密消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");temp = System.currentTimeMillis();String messageDe = decrypt(messageEn, keyMap.get(1));System.out.println("解密:" + messageDe);System.out.println("解密消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");}}以上这篇java RSAUtils 加密⼯具类操作就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

非对称加密算法（RSA、DSA、ECC、DH）

非对称加密算法（RSA、DSA、ECC、DH）

⾮对称加密算法（RSA、DSA、ECC、DH）⾮对称加密算法 (RSA、DSA、ECC、DH)1.1 概念⾮对称加密需要两个密钥：公钥 (publickey) 和私钥 (privatekey)。

公钥和私钥是⼀对，如果⽤公钥对数据加密，那么只能⽤对应的私钥解密。

如果⽤私钥对数据加密，只能⽤对应的公钥进⾏解密。

因为加密和解密⽤的是不同的密钥，所以称为⾮对称加密。

⾮对称加密算法的保密性好，它消除了最终⽤户交换密钥的需要。

但是加解密速度要远远慢于对称加密，在某些极端情况下，甚⾄能⽐对称加密慢上1000倍。

1.2 特点算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，⽽使得加密解密速度没有对称加密解密的速度快。

对称密码体制中只有⼀种密钥，并且是⾮公开的，如果要解密就得让对⽅知道密钥。

所以保证其安全性就是保证密钥的安全，⽽⾮对称密钥体制有两种密钥，其中⼀个是公开的，这样就可以不需要像对称密码那样传输对⽅的密钥了。

这样安全性就⼤了很多。

1.3 ⼯作原理(1) A 要向 B 发送信息，A 和 B 都要产⽣⼀对⽤于加密和解密的公钥和私钥。

(2) A 的私钥保密，A 的公钥告诉 B；B 的私钥保密，B 的公钥告诉 A。

(3) A 要给 B 发送信息时，A ⽤ B 的公钥加密信息，因为 A 知道 B 的公钥。

(4) A 将这个消息发给 B (已经⽤ B 的公钥加密消息)。

(5) B 收到这个消息后，B ⽤⾃⼰的私钥解密 A 的消息。

其他所有收到这个报⽂的⼈都⽆法解密，因为只有 B 才有 B 的私钥。

1.4 主要算法RSA、Elgamal、背包算法、Rabin、D-H、ECC (椭圆曲线加密算法)。

使⽤最⼴泛的是 RSA 算法，Elgamal 是另⼀种常⽤的⾮对称加密算法。

1.5 应⽤场景(1) 信息加密收信者是唯⼀能够解开加密信息的⼈，因此收信者⼿⾥的必须是私钥。

发信者⼿⾥的是公钥，其它⼈知道公钥没有关系，因为其它⼈发来的信息对收信者没有意义。

非对称加密算法范文

非对称加密算法范文

非对称加密算法范文非对称加密算法（Asymmetric encryption algorithm），也被称为公钥加密算法，是一种加密方法，使用了一对密钥（公钥和私钥）来进行加密和解密操作。

与对称加密算法相比，非对称加密算法具有更高的安全性。

非对称加密算法的基本原理是，产生一对密钥，其中一个是公钥（public key），可自由公开，用于加密数据；另一个是私钥（private key），需要保密，用于解密已加密的数据。

公钥和私钥是一对相关联的密钥，它们能够互相解密对方加密的数据。

1.RSA算法：RSA算法是一种最早应用并广泛使用的非对称加密算法，也是当前最常见的非对称加密算法。

RSA算法基于两个大质数的乘积难以分解的数学问题，通过大数分解困难实现了强大的安全性。

2. 椭圆曲线加密算法（Elliptic Curve Cryptography，ECC）：ECC算法利用椭圆曲线上的离散对数难题来实现加密操作。

相较于RSA算法，ECC算法在相同的安全性下使用更短的密钥，计算量更小，适用于资源有限的环境。

3. Elgamal算法：Elgamal算法主要用于密钥交换过程中的加密操作，利用离散对数的困难性实现加密和解密。

它具有一定的安全性和较高的计算复杂度，但由于其速度相对较慢，一般常用于密钥交换的初期过程。

4.DSA算法：DSA算法是一种数字签名算法，主要用于身份验证和数据完整性校验。

DSA算法结合了哈希函数和离散对数问题，通过数字签名的方式保证信息的可靠性。

1.更高的安全性：非对称加密算法通过使用不同的密钥进行加密和解密，避免了对称加密算法中密钥容易被窃取的问题。

即使公钥被泄露，私钥仍然可以保证数据的安全。

2.密钥交换方便：使用非对称加密算法，可以在不安全的通道上进行密钥交换，确保通信过程中的密钥安全。

3.数字签名：非对称加密算法可以用于生成和验证数字签名，以验证消息的完整性和认证通信方的身份。

然而，非对称加密算法也存在一些限制和挑战：1.计算复杂度高：非对称加密算法的计算复杂度较高，相比对称加密算法而言，执行加密和解密操作会消耗更多的计算资源。

Java使用数字证书加密文件(含代码)

Java使用数字证书加密文件(含代码)

JA V A 使用数字证书加密解密文件总结目录1.编写目的 (3)2.JA V A生产数字证书 (4)2.1.1 keystore(JKS) 的生成 (4)2.1.2 导出公钥 (5)3.使用JKS私钥加密文件 (5)4.转换为PFX格式私钥 (6)5.使用PFX加密文件 (7)6 源代码 (8)6.1 用到的JAR包 (8)6.2 示例代码 (8)6.2.1 Test.java (8)6.2.2 RsaUtil.java (10)6.2.3 Base64.java (19)7.结束语 (26)1.编写目的学习RSA算法,读取数字证书中的私钥对文件进行加密,使用数字证书的公钥解密,这种方式就是RSA算法.自己对RSA算法的理解:⏹私钥加密公钥解密:如果用私钥对文件加密,发给别人,别人用我公布的公钥进行解密,实现这个文件就是我本人制作的,不是别人做的.⏹公钥加密私钥解密:如果别人用我的公钥加密文件,那么只能我一个人看,只有使用我的私钥进行解密,私钥一定是不能告诉其他人的.本文讲解如何用JKS私钥对文件进行加密,用对于CRT公钥进行解密,将JKS私钥转换为PFX格式私钥,并用PFX私钥对文件进行加密解密Jks:是JA V A的keytools证书工具支持的证书私钥格式pfx:是微软支持的私钥格式⏹2.JAVA生产数字证书为了实现数字证书加密文件,我们首先要制作几个数字证书，如果你已经有了pfx格式的数字证书并且知道其密码，以及对应crt或者cer格式的公钥证书则跳过本章.2.1 keytool 创建数字证书Keytool是一个Java数据证书的管理工具,Keytool将密钥（key）和证书（certificates）存在一个称为keystore的文件中在keystore里，包含两种数据：⏹密钥实体（Key entity）：密钥（secret key）又或者是私钥⏹配对公钥（采用非对称加密）：可信任的证书实体（trusted certificate entries），只包含公钥2.1.1 keystore(JKS) 的生成●分阶段生成：命令格式：keytool -genkey -alias yushan(别名) -keypass yushan(别名密码) -keyalg RSA(算法) -keysize 1024(密钥长度) -validity 365(有效期，天单位) -keystore e:\yushan.keystore(指定生成证书的位置和证书名称) -storepass 123456(获取keystore信息的密码)；示例：1）cmd下进入java/bin2）输入命令keytool -genkey -alias myalias-keypass 123456-keyalg RSA-keysize 1024 -validity 365 -keystore d: \myalias.keystore -storepass 123456●一次性生成：keytool -genkey -alias yushan -keypass yushan -keyalg RSA -keysize 1024 -validity 365 -keystore e:\yushan.keystore -storepass 123456 -dname "CN=(名字与姓氏), OU=(组织单位名称), O=(组织名称), L=(城市或区域名称), ST=(州或省份名称), C=(单位的两字母国家代码)";(中英文即可)无例图2.1.2 导出公钥命令：keytool -export -alias myalias -keystore d:\myalias.keystore -file d:\myalias.crt -storepass 123456创建结果：3.使用JKS私钥加密文件//工具类RSAUtil rsa = new RSAUtil();//从jks私钥中获取私钥加密串PrivateKey priKeyFromKs = rsa.getPriKeyFromKS("d:\\myalias.keystore","123456", "myalias", "123456");//从jks私钥中获取公钥解密串PublicKey pubKeyFromKS = rsa.getPubKeyFromKS("d:\\myalias.keystore", "123456", "myalias");//从crt公钥中获取公钥解密串PublicKey pubKeyFromCrt = rsa.getPubKeyFromCRT("d:\\myalias.crt");//用私钥串加密rsa.encryptWithPrv("d:\\file.xml",priKeyFromKs,"d:\\file_encWithKSPri.xml", true);//用jks公钥串解密rsa.decryptWithPub("d:\\file_encWithKSPri.xml", pubKeyFromKS, true,"d:\\file_encWithKSPri_decKs.xml");//用crt公钥串解密rsa.decryptWithPub("d:\\file_encWithKSPri.xml", pubKeyFromCrt, true, "d:\\file_encWithKSPri_decCrt.xml");4.转换为PFX格式私钥如果你已经有了pfx格式的数字证书并且知道其密码，以及对应crt或者cer格式的公钥证书则跳过本章.4.1 转换工具转换工具我使用的是kestore-export下载kestore-export.rar 请百度搜索，我也会往CSDN上上传，请直接搜索kestore-export.rar。

常用加密算法学习总结之非对称加密

常用加密算法学习总结之非对称加密

常⽤加密算法学习总结之⾮对称加密公开密钥密码学（英语：Public-key cryptography）也称⾮对称式密码学（英语：Asymmetric cryptography）是密码学的⼀种演算法。

常⽤的⾮对称加密算法有 RSA DSA ECC 等。

⾮对称加密算法使⽤公钥、私钥来加解密。

公钥与私钥是成对出现的。

多个⽤户（终端等）使⽤的密钥交公钥，只有⼀个⽤户（终端等）使⽤的秘钥叫私钥。

使⽤公钥加密的数据只有对应的私钥可以解密；使⽤私钥加密的数据只有对应的公钥可以解密。

⾮对称加密通信过程下⾯我们来看⼀看使⽤公钥密码的通信流程。

假设Alice要给Bob发送⼀条消息，Alice是发送者，Bob是接收者，⽽这⼀次窃听者Eve依然能够窃所到他们之间的通信内容。

⑴ Alice与bob事先互不认识，也没有可靠安全的沟通渠道，但Alice现在却要透过不安全的互联⽹向bob发送信息。

⑵ Alice撰写好原⽂，原⽂在未加密的状态下称之为明⽂ plainText。

⑶ bob使⽤密码学安全伪随机数⽣成器产⽣⼀对密钥，其中⼀个作为公钥 publicKey，另⼀个作为私钥 privateKey。

⑷ bob可以⽤任何⽅法传送公钥publicKey 给Alice，即使在中间被窃听到也没问题。

⑸ Alice⽤公钥publicKey把明⽂plainText进⾏加密，得到密⽂ cipherText⑹ Alice可以⽤任何⽅法传输密⽂给bob，即使中间被窃听到密⽂也没问题。

⑺ bob收到密⽂，⽤私钥对密⽂进⾏解密，得到明⽂ plainText。

由于其他⼈没有私钥，所以⽆法得知明⽂；如果Alice，在没有得到bob私钥的情况下，她将重新得到原⽂。

Processing math: 100%RSARSA是⼀种⾮对称加密算法，是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年⼀起提出，并以三⼈姓⽒开头字母拼在⼀起组成的。

JAVA实现AES加密算法代码

JAVA实现AES加密算法代码

JAVA实现AES加密算法代码JA V A实现AES加密算法代码近些年DES使用越来越少，原因就在于其使用56位密钥，比较容易被破解，近些年来逐渐被AES替代，AES已经变成目前对称加密中最流行算法之一；AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据。

本文就简单介绍如何通过JA V A实现AES加密。

1. JA V A 实现闲话少许，掠过AES加密原理及算法，关于这些直接搜索专业网站吧，我们直接看JA V A的具体实现。

1.1 加密代码有详细解释，不多废话。

/*** 加密** @param content 需要加密的内容*@param password 加密密码* @return*/public static byte[] encrypt(String content, String password) {try {KeyGenerator kgen =KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) { e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (UnsupportedEncodingException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}/*** 加密** @param content 需要加密的内容* @param password 加密密码* @return*/ public static byte[] encrypt(String content, String password) {try {KeyGenerator kgen =KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8");SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器cipher.init(Cipher.DECRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(content);return result; //加密} catch (NoSuchAlgorithmException e){ e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}/**解密* @param content 待解密内容* @param password 解密密钥* @return*/public static byte[] decrypt(byte[] content, String password) {try {KeyGenerator kgen =KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器cipher.init(Cipher.DECRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(content);return result; //加密} catch (NoSuchAlgorithmException e){ e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}2.3 测试代码String content = "test";String password = "12345678";//加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);//解密byte[] decryptResult = decrypt(encryptResult,password); System.out.println("解密后：" + new String(decryptResult)); String content = "test";String password = "12345678"; //加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);//解密byte[] decryptResult =decrypt(encryptResult,password);System.out.println("解密后：" + new String(decryptResult));输出结果如下：加密前：test解密后：test 2.4 容易出错的地方但是如果我们将测试代码修改一下，如下：String content = "test";String password = "12345678";//加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);try {String encryptResultStr = newString(encryptResult,"utf-8");//解密byte[] decryptResult =decrypt(encryptResultStr.getBytes("utf-8"),password); System.out.println("解密后：" + newString(decryptResult));} catch (UnsupportedEncodingException e){ e.printStackTrace();}String content = "test"; String password = "12345678";//加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);try {String encryptResultStr = newString(encryptResult,"utf-8");//解密byte[] decryptResult =decrypt(encryptResultStr.getBytes("utf-8"),password); System.out.println("解密后：" + newString(decryptResult));} catch(UnsupportedEncodingException e){ e.printStackTrace();}则，系统会报出如下异常：javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher atcom.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA 13*..)at javax.crypto.Cipher.doFinal(DashoA13*..)这主要是因为加密后的byte数组是不能强制转换成字符串的，换言之：字符串和byte数组在这种情况下不是互逆的；要避免这种情况，我们需要做一些修订，可以考虑将二进制数据转换成十六进制表示，主要有如下两个方法： 2.4.1将二进制转换成16进制/**将二进制转换成16进制* @param buf* @return*/public static String parseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}returnsb.toString();}/**将二进制转换成16进制*@param buf* @return*/public static StringparseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}returnsb.toString();} 2.4.2 将16进制转换为二进制/**将16进制转换为二进制* @param hexStr*@return*/public static byte[]parseHexStr2Byte(String hexStr) {if (hexStr.length() return null;byte[] result = new byte[hexStr.length()/2]; for (int i = 0;i int high =Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);intlow = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16); result[i] = (byte) (high * 16 + low);}return result;}/**将16进制转换为二进制* @param hexStr*@return*/public static byte[]parseHexStr2Byte(String hexStr) {if (hexStr.length() return null;byte[] result = new byte[hexStr.length()/2]; for (int i = 0;i int high =Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);intlow = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);result[i] = (byte) (high * 16 + low);}return result;}然后，我们再修订以上测试代码，如下：String content = "test";String password = "12345678"; //加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后：" + encryptResultStr);//解密byte[] decryptFrom =parseHexStr2Byte(encryptResultStr);byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后：" + new String(decryptResult)); String content = "test";String password = "12345678"; //加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后：" + encryptResultStr);//解密byte[] decryptFrom =parseHexStr2Byte(encryptResultStr);byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后：" + new String(decryptResult));测试结果如下：加密前：test加密后：73C58BAFE578C59366D8C995CD0B9D6D解密后：test2.5 另外一种加密方式还有一种加密方式，大家可以参考如下：/*** 加密** @param content 需要加密的内容* @param password 加密密码*@return*/public static byte[] encrypt2(String content, String password) {try {SecretKeySpec key = new SecretKeySpec(password.getBytes(), "AES");Cipher cipher =Cipher.getInstance("AES/ECB/NoPadding");byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) { e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (UnsupportedEncodingException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}/*** 加密** @param content 需要加密的内容* @param password 加密密码* @return*/ public static byte[] encrypt2(String content, String password) {try {SecretKeySpec key = newSecretKeySpec(password.getBytes(), "AES");Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) { e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (UnsupportedEncodingException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}这种加密方式有两种限制密钥必须是16位的待加密内容的长度必须是16的倍数，如果不是16的倍数，就会出如下异常：javax.crypto.IllegalBlockSizeException: Input length not multiple of 16 bytes atcom.sun.crypto.provider.SunJCE_f.a(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA 13*..)at javax.crypto.Cipher.doFinal(DashoA13*..)要解决如上异常，可以通过补全传入加密内容等方式进行避免。

关于java3DES加密解密偏移量代码示例

关于java3DES加密解密偏移量代码示例

关于java3DES加密解密偏移量代码⽰例// 3DES加密public static String getEnc3DES(String data, String key, String iv) throws Exception {Cipher cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("gb2312"));IvParameterSpec ivs = new IvParameterSpec(iv.getBytes("gb2312"));SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");SecretKey securekey = keyFactory.generateSecret(dks);cipher.init(Cipher.ENCRYPT_MODE, securekey, ivs);BASE64Encoder base64Encoder = new BASE64Encoder();return base64Encoder.encode(cipher.doFinal(data.getBytes("GB2312")));}// 3DES解密public static String getDes3DES(String data, String key, String iv) throws Exception {BASE64Decoder base64Decoder = new BASE64Decoder();byte[] databyte = base64Decoder.decodeBuffer(data);Cipher cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("gb2312"));IvParameterSpec ivs = new IvParameterSpec(iv.getBytes("gb2312"));SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");SecretKey securekey = keyFactory.generateSecret(dks);cipher.init(Cipher.DECRYPT_MODE, securekey, ivs);return new String(cipher.doFinal(databyte), "GB2312");} 说明：KEY值根据⾃⼰需求⽣成。

非对称加密算法--DH

非对称加密算法--DH

⾮对称加密算法--DH注意：本节内容主要参考⾃《Java加密与解密的艺术（第2版）》第8章“⾼等加密算法--⾮对称加密算法”11.1、⾮对称加密算法特点：发送⽅和接收⽅均有⼀个密钥对（公钥+私钥），其中公钥传播，私钥⾃⼰保存，不需要传播私钥不需要传播的特性解决了对称加密算法中密钥传播的困难（这个困难⼀般通过线下传递可以解决）加密安全性极⾼，只⽤于⼀些电⼦商务⽹站，加解密速度远低于对称加密⼀般情况下，为了解决⾮对称加密算法加解密速度低的问题，采⽤⾮对称加密（使⽤公钥+私钥对对称加密的密钥进⾏加解密）+对称加密（加解密数据）相结合的⽅式。

常见算法：DH（⾮对称加密的基⽯）RSA（⾮对称加密的经典，除了可⽤于⾮对称加密，也可⽤于数字签名，RSA--155(512位密钥)已被破解）ElGamal11.2、DH（仅能⽤于密钥分配，不能加解密数据）实现⽅式：JDK（密钥长度：512~1024中的64的整数倍）⼏个概念：密钥对：公钥+私钥本地密钥：对称加密的密钥整个流程：1）甲⼄双⽅初始化各⾃的密钥对甲⽅构建出密钥对keyPair1-->⼄⽅使⽤甲⽅的密钥对中的公钥publicKey1构建出⾃⼰的密钥对keyPair22）甲⼄双⽅构建各⾃的本地密钥甲⽅使⽤⾃⼰的私钥privateKey1+⼄⽅的公钥publicKey2构建出⾃⼰的本地密钥key1⼄⽅使⽤⾃⼰的私钥privateKey2+甲⽅的公钥publicKey1构建出⾃⼰的本地密钥key2最后会发现key1==key2，这两个本地密钥将会是接下来对对称加密所使⽤的密钥3）发送⽅（甲⽅或⼄⽅均可）使⽤本地密钥+对称加密算法对待加密数据进⾏加密，传递给接收⽅4）接收⽅使⽤本地密钥+对称加密算法对待解密数据进⾏解密1 package com.util.dh;23 import java.io.UnsupportedEncodingException;4 import java.security.InvalidAlgorithmParameterException;5 import java.security.InvalidKeyException;6 import java.security.Key;7 import java.security.KeyFactory;8 import java.security.KeyPair;9 import java.security.KeyPairGenerator;10 import java.security.NoSuchAlgorithmException;11 import java.security.PrivateKey;12 import java.security.PublicKey;13 import java.security.spec.InvalidKeySpecException;14 import java.security.spec.PKCS8EncodedKeySpec;15 import java.security.spec.X509EncodedKeySpec;1617 import javax.crypto.BadPaddingException;18 import javax.crypto.Cipher;19 import javax.crypto.IllegalBlockSizeException;20 import javax.crypto.KeyAgreement;21 import javax.crypto.NoSuchPaddingException;22 import javax.crypto.interfaces.DHPublicKey;23 import javax.crypto.spec.DHParameterSpec;24 import javax.crypto.spec.SecretKeySpec;2526 import mons.codec.binary.Base64;2728 /**29 * 基于JDK的DH算法，⼯作模式采⽤ECB30 */31 public class DHJDK {32 private static final String ENCODING = "UTF-8";33 private static final String FDC_KEY_ALGORITHM = "DH";//⾮对称加密密钥算法34 private static final String DC_KEY_ALGORITHM = "AES";//产⽣本地密钥的算法（对称加密密钥算法）35 private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//加解密算法格式：算法/⼯作模式/填充模式注意：ECB不使⽤IV参数36 private static final int FDC_KEY_SIZE = 512;//⾮对称密钥长度（512~1024之间的64的整数倍）3738 /**39 * ⽣成甲⽅密钥对40 */41 public static KeyPair initKey() throws NoSuchAlgorithmException{42 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(FDC_KEY_ALGORITHM);//密钥对⽣成器43 keyPairGenerator.initialize(FDC_KEY_SIZE);//指定密钥长度44 KeyPair keyPair = keyPairGenerator.generateKeyPair();//⽣成密钥对45 return keyPair;46 }4748 /**49 * ⽣成⼄⽅密钥对50 * @param key 甲⽅公钥51 */52 public static KeyPair initKey(byte[] key) throws NoSuchAlgorithmException,53 InvalidKeySpecException,54 InvalidAlgorithmParameterException{55 KeyFactory keyFactory = KeyFactory.getInstance(FDC_KEY_ALGORITHM);//密钥⼯⼚56 PublicKey publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(key));//还原甲⽅公钥57 DHParameterSpec dHParameterSpec = ((DHPublicKey)publicKey).getParams();5859 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());//⼄⽅密钥对⽣成器60 keyPairGenerator.initialize(dHParameterSpec);//使⽤甲⽅公钥参数初始化⼄⽅密钥对⽣成器61 KeyPair keyPair = keyPairGenerator.generateKeyPair();//⽣成密钥对62 return keyPair;63 }6465 /**66 * DH加密67 * @param data 带加密数据68 * @param keyByte 本地密钥，由getSecretKey(byte[] publicKey, byte[] privateKey)产⽣69 */70 public static byte[] encrypt(String data, byte[] keyByte) throws NoSuchAlgorithmException,71 NoSuchPaddingException,72 InvalidKeyException,73 IllegalBlockSizeException,74 BadPaddingException,75 UnsupportedEncodingException {76 Key key = new SecretKeySpec(keyByte, DC_KEY_ALGORITHM);//⽣成本地密钥7778 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);79 cipher.init(Cipher.ENCRYPT_MODE, key);//设置加密模式并且初始化key80 return cipher.doFinal(data.getBytes(ENCODING));81 }8283 /**84 * DH解密85 * @param data 待解密数据为字节数组86 * @param keyByte 本地密钥，由getSecretKey(byte[] publicKey, byte[] privateKey)产⽣87 */88 public static byte[] decrypt(byte[] data, byte[] keyByte) throws NoSuchAlgorithmException,89 NoSuchPaddingException,90 InvalidKeyException,91 IllegalBlockSizeException,92 BadPaddingException {93 Key key = new SecretKeySpec(keyByte, DC_KEY_ALGORITHM);//⽣成本地密钥94 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);95 cipher.init(Cipher.DECRYPT_MODE, key);96 return cipher.doFinal(data);97 }9899 /**100 * 根据本⽅私钥与对⽅公钥构建本地密钥（即对称加密的密钥）101 * @param publicKey 对⽅公钥102 * @param privateKey 本⽅私钥103 */104 public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws NoSuchAlgorithmException,105 InvalidKeySpecException,106 InvalidKeyException{107 KeyFactory keyFactory = KeyFactory.getInstance(FDC_KEY_ALGORITHM);//密钥⼯⼚108 PublicKey pubkey = keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));//还原公钥109 PrivateKey prikey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));//还原私钥110111 KeyAgreement keyAgreement = KeyAgreement.getInstance(keyFactory.getAlgorithm());112 keyAgreement.init(prikey);113 keyAgreement.doPhase(pubkey, true);114 return keyAgreement.generateSecret(DC_KEY_ALGORITHM).getEncoded();//⽣成本地密钥（对称加密的密钥）115 }116117 /**118 * 获取公钥119 */120 public static byte[] getPublicKey(KeyPair keyPair){121 return keyPair.getPublic().getEncoded();122 }123124 /**125 * 获取私钥126 */127 public static byte[] getPrivateKey(KeyPair keyPair){128 return keyPair.getPrivate().getEncoded();129 }130131 /**132 * 测试133 */134 public static void main(String[] args) throws NoSuchAlgorithmException,135 InvalidKeySpecException,136 InvalidAlgorithmParameterException,137 InvalidKeyException,138 NoSuchPaddingException,139 IllegalBlockSizeException,140 BadPaddingException,141 UnsupportedEncodingException {142 byte[] pubKey1;//甲⽅公钥143 byte[] priKey1;//甲⽅私钥144 byte[] key1;//甲⽅本地密钥145 byte[] pubKey2;//⼄⽅公钥146 byte[] priKey2;//⼄⽅私钥147 byte[] key2;//⼄⽅本地密钥148149 /*********************测试是否可以正确⽣成以上6个key，以及key1与key2是否相等*********************/150 KeyPair keyPair1 = DHJDK.initKey();//⽣成甲⽅密钥对151 pubKey1 = DHJDK.getPublicKey(keyPair1);152 priKey1 = DHJDK.getPrivateKey(keyPair1);153154 KeyPair keyPair2 = DHJDK.initKey(pubKey1);//根据甲⽅公钥⽣成⼄⽅密钥对155 pubKey2 = DHJDK.getPublicKey(keyPair2);156 priKey2 = DHJDK.getPrivateKey(keyPair2);157158 key1 = DHJDK.getSecretKey(pubKey2, priKey1);//使⽤对⽅公钥和⾃⼰私钥构建本地密钥159 key2 = DHJDK.getSecretKey(pubKey1, priKey2);//使⽤对⽅公钥和⾃⼰私钥构建本地密钥160161 System.out.println("甲⽅公钥pubKey1-->"+Base64.encodeBase64String(pubKey1)+"@@pubKey1.length-->"+pubKey1.length); 162 System.out.println("甲⽅私钥priKey1-->"+Base64.encodeBase64String(priKey1)+"@@priKey1.length-->"+priKey1.length); 163 System.out.println("⼄⽅公钥pubKey2-->"+Base64.encodeBase64String(pubKey2)+"@@pubKey2.length-->"+pubKey2.length); 164 System.out.println("⼄⽅私钥priKey2-->"+Base64.encodeBase64String(priKey2)+"@@priKey2.length-->"+priKey2.length); 165 System.out.println("甲⽅密钥key1-->"+Base64.encodeBase64String(key1));166 System.out.println("⼄⽅密钥key2-->"+Base64.encodeBase64String(key2));167168 /*********************测试甲⽅使⽤本地密钥加密数据向⼄⽅发送，⼄⽅使⽤本地密钥解密数据*********************/169 System.out.println("甲⽅-->⼄⽅");170 String data = "找⼀个好姑娘啊！";171 byte[] encodeStr = DHJDK.encrypt(data, key1);172 System.out.println("甲⽅加密后的数据-->"+Base64.encodeBase64String(encodeStr));173 byte[] decodeStr = DHJDK.decrypt(encodeStr, key2);174 System.out.println("⼄⽅解密后的数据-->"+new String(decodeStr,"UTF-8"));175176 /*********************测试⼄⽅使⽤本地密钥加密数据向甲⽅发送，甲⽅使⽤本地密钥解密数据*********************/177 System.out.println("⼄⽅-->甲⽅");178 String data2 = "找⼀个好姑娘啊！";179 byte[] encodeStr2 = DHJDK.encrypt(data2, key2);180 System.out.println("⼄⽅加密后的数据-->"+Base64.encodeBase64String(encodeStr2));181 byte[] decodeStr2 = DHJDK.decrypt(encodeStr, key1);182 System.out.println("甲⽅解密后的数据-->"+new String(decodeStr2,"UTF-8"));183 }184 }。

DES、AES、RSA等常用加密算法介绍与比较

DES、AES、RSA等常用加密算法介绍与比较

DES、AES、RSA等常用加密算法介绍与比较文本先简单介绍常用的加密算法，后面将逐步推送每个加密算法的加密原理与应用及 java 实现方式。

加密算法分对称加密和非对称算法，其中对称加密算法的加密与解密密钥相同，非对称加密算法的加密密钥与解密密钥不同，此外，还有一类不需要密钥的散列算法。

常见的对称加密算法主要有 DES、3DES、AES 等，常见的非对称算法主要有 RSA、DSA 等，散列算法主要有 SHA-1、MD5 等。

对称算法又可分为两类。

一次只对明文中的单个位（有时对字节）运算的算法称为序列算法或序列密码。

另一类算法是对明文的一组位进行运算（即运算之前将明文分为若干组，然后分别对每一组进行运算，这些位组称为分组），相应的算法称为分组算法或分组密码。

DES 加密算法DES 加密算法是一种分组密码，以 64 位为分组对数据加密，它的密钥长度是 56 位，加密解密用同一算法。

DES 加密算法是对密钥进行保密，而公开算法，包括加密和解密算法。

这样，只有掌握了和发送方相同密钥的人才能解读由 DES 加密算法加密的密文数据。

因此，破译 DES 加密算法实际上就是搜索密钥的编码。

对于 56 位长度的密钥来说，如果用穷举法来进行搜索的话，其运算次数为 2 的 56 次方。

3DES（Triple DES）是基于 DES 的对称算法，对一块数据用三个不同的密钥进行三次加密，强度更高；AES 加密算法AES 加密算法是密码学中的高级加密标准，该加密算法采用对称分组密码体制，密钥长度的最少支持为 128、192、256，分组长度 128 位，算法应易于各种硬件和软件实现。

这种加密算法是美国联邦政府采用的区块加密标准，AES 标准用来替代原先的 DES，已经被多方分析且广为全世界所使用。

RSA 加密算法RSA 加密算法是目前最有影响力的公钥加密算法，并且被普遍认为是目前最优秀的公钥方案之一。

RSA 是第一个能同时用于加密和数宇签名的算法，它能够抵抗到目前为止已知的所有密码攻击，已被 ISO 推荐为公钥数据加密标准。

第三讲 数据加密-非对称加密算法讲解

第三讲 数据加密-非对称加密算法讲解

解决方法：
一钥一密 定期更换
密钥的管理和分发

密钥的分发
– 问题？ – 改进！
非对称加密算法
算法和密钥

明文M，密文C，加密E，解密D 密钥用K表示
– K可以是很多数值里的任意值，密钥K的可能值的范围叫做 密钥空间。加密和解密运算都使用这个密钥，即运算都依赖 于密钥，并用K作为下标表示，加解密函数表达为： – E（M , k）=C – D（C , k）=M – D（E（M , k）, k）=M，如图所示。
Triple-DES

三重两钥DES（tri-DES/2） 112-bites(equivalent to 34 digits) Any Number between 0 to 5192296858534827628530496329220095
– – – – 两个密钥K1,K2 Encrypt with K1 Decrypt with K2 Encrypt with K1
RSA算法描述1
描述如下： （1）、生成两个大素数p和q。 （2）、计算这两个素数的乘积n=p×q。 （3）、计算欧拉函数φ(n)=(p-1)(q-1)。
– 欧拉函数参见教材p63
（4）、选择一个随机数e满足1<e<φ(n)，并且e和 φ(n)互质，即gcd(b, φ(n))=1。 （5）、计算ed=1 mod φ(n)。
AES

National Security Agency approved AES in june 2003 for pretecting top-level secrets within US gov agencies
密钥的管理和分发

使用同样的密钥的范围

java加解密算法--常见加解密算法

java加解密算法--常见加解密算法

java加解密算法--常见加解密算法什么是加密算法？百度百科给出的解释如下：数据加密的基本过程就是对原来为明⽂的⽂件或数据按某种算法进⾏处理，使其成为不可读的⼀段代码，通常称为“密⽂”，使其只能在输⼊相应的密钥之后才能显⽰出本来内容，通过这样的途径来达到保护数据不被⾮法⼈窃取、阅读的⽬的。

该过程的逆过程为解密，即将该编码信息转化为其原来数据的过程。

简单来说，就是把某⼀段数据（明⽂），按照“某种规则”转换成另外⼀段不可读的数据（密⽂）。

这⾥选定的“规则”，就是加密算法。

理所当然，当别⼈拿到“密⽂”，解析出“明⽂”的难度取决于加密算法的破解难度。

1. 算法种类单向加密对称加密⾮对称加密1.1 单向加密即加密之后不能解密，⼀般⽤于数据验证1） Base64Base64 编码是从⼆进制到字符的过程，⽤ 64 个字符来表⽰任意的⼆进制数据。

对于开发⼈员来说，拿到密⽂，很容易就能够解析成明⽂。

因此严格来说，Base64不能称之为加密算法，仅仅是⼀种编码⽅式。

它常常⽤于发送Http请求时对URL中参数的编码，保证不是⼀眼就看出来了这些参数的意义，或者图⽚编码传输。

转换⽅法：1 字节（byte） = 8 ⽐特位（bit）Base64 定义了 64 （2^6）个可打印字符表⽰⼆进制的⽅法，也就是说 6 个 bit 的⼆进制数据可以⽤对应的字符代替表⽰对于连续多个⼆进制数据，每 3 个字节⼀组进⾏转换，3个字节 24 bit，然后将其分为 4 部分（3×8 = 4×6），每个部分刚好 6 bit，⾼位补0，将 6 bit ⼆进制转换为 Base64 定义的字符即完成转换若⼆进制数据字节数不是 3 的倍数，Base64 就将剩下的⼆进制数据补 0 ⾄ 3 的倍数，全 0 的⽤字符 “=” 代替⽐如：我要⽤Base64编码⼀个字符串“abc”，实际算法如下：'a','b','c'的ASCII标准编码分别为（⼗进制）97,98,99,因此⽤⼆进制表⽰“abc”字符串就是：01100001，01100010，01100011 ---3组，每组8字节Base64的原理：将这三组8字节，分成4组6字节011000，010110， 001001，100011 ---4组，每组6字节⾼位补000011000，00010110， 00001001，00100011这四个⼆进制数组对应⼗进制的数值分别是：24，22，9，35，RFC2045（Base64解码表）分别为：Y,W,J,j即："abc"经过Base64编码后，为"YWJj"。

java相关加密解密方法

java相关加密解密方法

java相关加密解密方法Java加密解密方法是保护数据安全的重要手段，本文将详细介绍几种常见的Java加密解密方法。

一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。

这种加密方式简单高效，但存在密钥管理的问题，因为所有用户都必须知道密钥。

在Java中，常用的对称加密算法有DES、3DES、AES等。

1. DES：Data Encryption Standard，数据加密标准，是一种使用56位密钥的对称块密码算法。

在Java中，我们可以使用javax.crypto.Cipher类来实现DES 加密解密。

2. 3DES：Triple Data Encryption Algorithm，三重数据加密算法，是DES的增强版本，使用三个不同的56位密钥进行三次加密。

在Java中，我们同样可以使用Cipher类来实现3DES加密解密。

3. AES：Advanced Encryption Standard，高级加密标准，是一种使用128、192或256位密钥的对称块密码算法。

在Java中，我们可以使用Cipher类来实现AES加密解密。

二、非对称加密算法非对称加密算法是一种使用一对密钥（公钥和私钥）进行加密和解密的算法。

公钥可以公开给所有人，而私钥需要保密。

在Java中，常用的非对称加密算法有RSA、DSA等。

1. RSA：Rivest-Shamir-Adleman，一种基于大数因子分解难题的非对称加密算法。

在Java中，我们可以使用java.security.KeyPairGenerator类生成RSA密钥对，然后使用Cipher类进行RSA加密解密。

2. DSA：Digital Signature Algorithm，数字签名算法，是一种基于整数有限域离散对数难题的非对称加密算法。

在Java中，我们可以使用KeyPairGenerator类生成DSA密钥对，然后使用Signature类进行DSA签名和验证。

java rsa 加密解密流程

java rsa 加密解密流程

java rsa 加密解密流程RSA是一种非对称加密算法，用于数据的加密和解密。

它涉及到公钥和私钥的使用，其中公钥用于加密数据，私钥用于解密数据。

下面是Java中使用RSA 加密和解密的基本流程：1. 生成密钥对：首先需要生成一对RSA密钥，包括公钥和私钥。

可以使用Java提供的`KeyPairGenerator`类来生成密钥对。

```javaKeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");keyPairGenerator.initialize(2048); // 指定密钥长度KeyPair keyPair = keyPairGenerator.generateKeyPair();PublicKey publicKey = keyPair.getPublic();PrivateKey privateKey = keyPair.getPrivate();```2. 加密数据：使用公钥对需要加密的数据进行加密。

可以使用`Cipher`类来进行加密操作。

```javaString data = "Hello, World!";Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] encryptedData = cipher.doFinal(data.getBytes());```3. 解密数据：使用私钥对加密后的数据进行解密，还原为原始数据。

```javacipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] decryptedData = cipher.doFinal(encryptedData);String decryptedText = new String(decryptedData);```请注意，以上示例代码只是一个简单的RSA加密和解密流程的示例。

java后台加密解密方法

java后台加密解密方法

java后台加密解密方法Java后台加密解密方法在当今互联网安全领域中具有重要意义。

为了保护数据的安全，各种加密算法应运而生。

本文将介绍几种常见的Java后台加密解密方法，包括RSA、AES、DES和SM2。

1.RSA加密解密原理及实现RSA是一种非对称加密算法，其公钥和私钥是成对存在的。

使用公钥加密后的数据只能通过私钥进行解密。

在Java中，我们可以使用KeyPairGenerator生成一对公私钥，然后使用RSAPrivateKey对数据进行解密。

2.AES加密解密原理及实现AES是一种对称加密算法，加密和解密过程使用相同的密钥。

在Java中，我们可以使用Java的加密库如Java Cryptography Extension (JCE)实现AES 加密解密。

3.DES加密解密原理及实现DES是一种对称加密算法，其加密过程和解密过程使用不同的密钥。

在Java中，我们可以使用Java Cryptography Extension (JCE)实现DES加密解密。

4.SM2加密解密原理及实现SM2是一种国密算法，具有非对称加密和对称加密的特点。

在前端，我们可以使用SM2加密请求参数，然后在后台使用对应的私钥进行解密。

在Java 中，我们可以使用Hutool库实现SM2加密解密。

5.总结：选择合适的加密解密方法及注意事项在实际应用中，选择合适的加密解密方法至关重要。

需要考虑数据安全性、算法复杂度、性能和兼容性等因素。

此外，还需注意以下几点：- 加密解密算法应根据实际需求进行选择，如对称加密算法适用于加密大量数据，非对称加密算法适用于加密少量数据；- 加密密钥和解密密钥应妥善保管，避免泄露；- 在传输加密数据时，应注意防范中间人攻击，可以使用SSL/TLS等安全协议进行保护；- 定期更新和升级加密算法，以应对潜在的安全威胁。

本文介绍了Java后台加密解密方法，包括RSA、AES、DES和SM2。

javasm3加密算法

javasm3加密算法

javasm3加密算法1.准备⼯作 所需jar包： bcprov-jdk15on-1.59.jar commons-lang3-3.1.jar 20200901 对应的maven依赖<!--sm3,sm4加密算法--><dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.66</version></dependency> import org.bouncycastle.crypto.digests.SM3Digest;import org.bouncycastle.crypto.macs.HMac;import org.bouncycastle.crypto.params.KeyParameter;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;import java.io.UnsupportedEncodingException;import java.security.Security;import java.util.Arrays;/*** sm3加密算法⼯具类* @explain 加密与加密结果验证（不可逆算法）* @author Marydon* @creationTime 2018年7⽉5⽇上午10:01:24* @version 1.0* @since*@*****************************/public class Sm3Utils {private static final String ENCODING = "UTF-8";static {Security.addProvider(new BouncyCastleProvider());}}　2.SM3加密 ⽅式⼀：不提供密钥/*** sm3算法加密* @explain* @param paramStr* 待加密字符串* @return 返回加密后，固定长度=32的16进制字符串*/public static String encrypt(String paramStr){// 将返回的hash值转换成16进制字符串String resultHexString = "";try {// 将字符串转换成byte数组byte[] srcData = paramStr.getBytes(ENCODING);// 调⽤hash()byte[] resultHash = hash(srcData);// 将返回的hash值转换成16进制字符串resultHexString = ByteUtils.toHexString(resultHash);} catch (UnsupportedEncodingException e) {e.printStackTrace();}return resultHexString;}/*** 返回长度=32的byte数组* @explain ⽣成对应的hash值* @param srcData* @return*/public static byte[] hash(byte[] srcData) {SM3Digest digest = new SM3Digest();digest.update(srcData, 0, srcData.length);byte[] hash = new byte[digest.getDigestSize()];digest.doFinal(hash, 0);return hash;}　 ⽅式⼆：⾃定义密钥/*** 通过密钥进⾏加密* @explain 指定密钥进⾏加密* @param key* 密钥* @param srcData* 被加密的byte数组* @return*/public static byte[] hmac(byte[] key, byte[] srcData) {KeyParameter keyParameter = new KeyParameter(key);SM3Digest digest = new SM3Digest();HMac mac = new HMac(digest);mac.init(keyParameter);mac.update(srcData, 0, srcData.length);byte[] result = new byte[mac.getMacSize()];mac.doFinal(result, 0);return result;} 3.加密数据校验/*** 判断源数据与加密数据是否⼀致* @explain 通过验证原数组和⽣成的hash数组是否为同⼀数组，验证2者是否为同⼀数据 * @param srcStr* 原字符串* @param sm3HexString* 16进制字符串* @return 校验结果*/public static boolean verify(String srcStr, String sm3HexString) {boolean flag = false;try {byte[] srcData = srcStr.getBytes(ENCODING);byte[] sm3Hash = ByteUtils.fromHexString(sm3HexString);byte[] newHash = hash(srcData);if (Arrays.equals(newHash, sm3Hash))flag = true;} catch (UnsupportedEncodingException e) {e.printStackTrace();}return flag;}　4.测试。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

} X509EncodedKeySpec keySpec = new X509EncodedKeySpec (publicKeyByte s); return keyFactory.generatePublic (keySpec); } catch (Exception e) { throw new RuntimeException ("load publicKey fail. " + e.getMessage ()); } } /** * 加载公钥（base64） * * @param publicKeyBase64 * 秘钥为BASE64编码 * @param keyAlgorithm * 如：RSA * @param providerName * 可以为空，如：BC * @return */ public static PublicKey loadPublicKey (String publicKeyBase64, String keyA lgorithm, String providerName) { byte [] publicKeyBytes = Encodes.decodeBase64(publicKeyBase64); return loadPublicKey (publicKeyBytes, keyAlgorithm, providerName); } /** * 加载公钥(⽂文件pem) * * @param publicKeyFile * 公钥秘钥⽂文件，内容为BASE64编码 * @param keyAlgorithm * 如：RSA * @param providerName * 可以为空，如：BC * @return */ public static PublicKey loadPublicKey (File publicKeyFile, String keyAlgor ithm, String providerName) { byte [] publicKeyBytes = null; try { publicKeyBytes = Encodes.decodeBase64(FileUtils.readFileToString (publicKeyFile));} catch (Exception e) {throw new RuntimeException ("加载公钥⽂文件内容失败:" + e.getMessage ())23242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768私钥的加载默认同公钥，这⾥里里不不在贴代码，从公钥稍微调整下就OKthrow new RuntimeException ("加载公钥⽂文件内容失败:" + e.getMessage ()); } finally { IOUtils.closeQuietly (in); } } /** * 从keystore 加载公钥 * * @param keystoreUri * @param keystoreType * @param keystorePassword * @return */ public static PublicKey loadPublicKeyFromKeyStore (String keystoreUri, Str ing keystoreType, String keystorePassword) { InputStream in = null; try { KeyStore keyStore = KeyStore.getInstance (keystoreType); Resource resource = new DefaultResourceLoader ().getResource (keyst oreUri); in = resource.getInputStream (); keyStore.load (in, keystorePassword.toCharArray ()); Enumeration <String > enumas = keyStore.aliases (); String keyAlias = null; if (enumas.hasMoreElements ()) { keyAlias = enumas.nextElement (); } return keyStore.getCertificate (keyAlias).getPublicKey ();} catch (Exception e) {throw new RuntimeException ("通过keystore 加载证书公钥失败:" + e.getMe ssage ());} finally {IOUtils.closeQuietly (in);}}4041424344454647484950515253545556575859606162636465666768697071私钥的加载加密和解密while (inputLen - offSet > 0) { if (inputLen - offSet > plainLength) { cache = cipher.doFinal (plainBytes, offSet, plainLength); } else { cache = cipher.doFinal (plainBytes, offSet, inputLen - off Set); } out.write (cache, 0, cache.length); i ++; offSet = i * plainLength; } byte [] encryptedData = out.toByteArray (); return encryptedData; } catch (Exception e) { throw new RuntimeException ("publicKey encrypt fail:" + e.getMessa ge ()); } finally { IOUtils.closeQuietly (out); } } public static String encryptByPublicKeyBase64(String plainText, PublicKey publicKey, String charset) { return Encodes.encodeBase64(encryptByPublicKey (getBytes (plainText, ch arset), publicKey)); } public static String encryptByPublicKeyBase64(String plainText, PublicKey publicKey) { return encryptByPublicKeyBase64(plainText, publicKey, DEFAULT_CHARSET ); }public static String encryptByPublicKeyHex (String plainText, PublicKey pu blicKey, String charset) {return Encodes.encodeHex (encryptByPublicKey (getBytes (plainText, chars et), publicKey));}public static String encryptByPublicKeyHex (String plainText, PublicKey pu blicKey) {return encryptByPublicKeyHex (plainText, publicKey, DEFAULT_CHARSET);}262728293031323334353637383940414243444546474849505152535455565758私钥解密/**1* 私钥解密 * * @param encryptedBytes * 密⽂文数据bytes * @param privateKey * 私钥 * @return 明⽂文数据bytes */ public static byte [] decryptByPrivateKey (byte [] encryptedBytes, PrivateKe y privateKey) { ByteArrayOutputStream out = null; try { Cipher cipher = Cipher.getInstance (privateKey.getAlgorithm ()); cipher.init (Cipher.DECRYPT_MODE, privateKey); int inputLen = encryptedBytes.length; out = new ByteArrayOutputStream (); int offSet = 0; byte [] cache; int i = 0; // 对数据分段解密 int keyLength = ((RSAPrivateKey) privateKey).getModulus ().bitLeng th () / 8; while (inputLen - offSet > 0) { if (inputLen - offSet > keyLength) { cache = cipher.doFinal (encryptedBytes, offSet, keyLength); } else { cache = cipher.doFinal (encryptedBytes, offSet, inputLen - offSet); } out.write (cache, 0, cache.length); i ++; offSet = i * keyLength; } byte [] decryptedData = out.toByteArray (); return decryptedData; } catch (Exception e) { throw new RuntimeException ("privateKey decrypt fail:" + e.getMess age ()); } finally { IOUtils.closeQuietly (out); } } public static String decryptByPrivateKeyBase64(String encryptedBase64, Pr ivateKey privateKey, String charset) { byte [] plainBytes = decryptByPrivateKey (Encodes.decodeBase64(encrypte dBase64), privateKey);2345678910111213141516171819202122232425262728293031323334353637383940414243444546474849签名和验签基本⽆无需考虑性能问题，我在imac 上实际测试⼀一般Signature 的初始化在2ms 左右，除⾮非要求极致性能，否则也不不⽤用做线程缓存。

相关文档
最新文档