java相关加密解密方法

java 密码加密解密方法在Java中，密码的加密和解密可以通过多种方式实现。

其中，常用的方法包括使用MessageDigest类进行加密，以及使用对称加密和非对称加密算法进行加密和解密。

一种常见的密码加密方法是使用MessageDigest类进行加密。

这可以通过以下步骤实现：首先，将密码转换为字节数组。

然后，使用MessageDigest类的getInstance方法获取特定的加密算法实例，例如SHA-256或MD5。

接下来，使用update方法将密码的字节数组传递给MessageDigest实例。

最后，使用digest方法获得加密后的字节数组，并将其转换为十六进制字符串或其他格式存储在数据库或其他地方。

另一种常见的方法是使用对称加密算法，例如AES或DES。

这些算法使用相同的密钥进行加密和解密。

在Java中，可以使用javax.crypto包中的类来实现对称加密。

通常，需要生成一个密钥并将其存储在安全的地方，然后使用该密钥对密码进行加密和解密。

此外，还可以使用非对称加密算法，例如RSA。

这种方法使用公钥对数据进行加密，然后使用私钥进行解密。

在Java中，可以使用java.security包中的类来实现非对称加密。

无论使用哪种方法，都需要注意密码安全的问题。

例如，密钥的安全存储和管理，以及密码传输过程中的安全性。

另外，还需要考虑密码的哈希加盐等技术来增加密码的安全性。

总之，在Java中实现密码的加密和解密有多种方法，开发人员可以根据实际需求和安全要求选择合适的加密算法和实现方式。

希望这些信息能够帮助你更好地理解Java中密码加密解密的方法。

JAVA加密解密之对称加密算法AESAES（Advanced Encryption Standard）是一种对称加密算法，也被称为Rijndael加密算法。

它是目前应用最广泛的加密算法之一，常用于保护数据的机密性。

AES算法是在公开的一种替代算法Rijndael的基础上，经美国国家标准与技术研究院（NIST）的认证，成为美国政府的标准加密算法。

AES算法使用固定长度的密钥来对数据进行加密和解密，密钥长度可以是128位、192位或256位。

AES算法通过对数据进行一系列的替换、转置和异或操作，以及多轮的加密处理来实现数据的加密。

加密过程可以简单地分为四个步骤：字节替换（SubBytes）、行移位（ShiftRows）、列混淆（MixColumns）和轮密钥加（AddRoundKey）。

解密过程则是加密过程的逆向操作。

字节替换（SubBytes）是AES算法的第一步，它将输入的明文字节映射到一个经过预定义的S盒（Substitution Box）变换后的值，这样可以增加数据的混淆性和扩散性。

行移位（ShiftRows）是AES算法的第二步，它将每一行的字节进行循环移位，使得输入数据的局部特征在整个加密过程中得到更好的扩散效果。

列混淆（MixColumns）是AES算法的第三步，它对输入数据的每一列进行一系列的线性变换，增加密文的随机性和混淆性。

轮密钥加（AddRoundKey）是AES算法的最后一步，它将每一轮的密钥与加密（或解密）轮次的状态矩阵进行异或操作，从而引入密钥的影响，增加数据的复杂性和随机性。

AES算法的安全性主要依赖于以下几个方面：1.替换和混淆：AES算法使用了非线性的S盒和列混淆操作，使得加密操作难以反向计算和预测。

2.扩散性：AES算法的多轮处理和行移位操作，使得每个明文字节的影响在加密过程中能够尽可能地扩散到输出密文。

3.密钥长度：AES算法支持不同长度的密钥，对于较长的密钥长度，破解算法需要更大的计算量。

javamd5加密和解密算法实例-回复Javamd5加密和解密算法实例在计算机领域中，数据的安全性是非常重要的。

为了保护数据免受未经授权的访问，数据通常需要进行加密。

MD5是一种常用的加密算法之一，它可以将数据转换为一串固定长度的密文。

在本文中，将详细介绍Java 中的MD5加密和解密算法的实例。

MD5（Message Digest algorithm 5）是一种单向加密算法，它将任意长度的数据块转换为固定长度的密文，通常为128位。

与传统的加密算法不同，MD5无法逆向解密，因此被广泛应用于密码存储和验证等领域。

在Java中，我们可以使用Java.security包中的MessageDigest类实现MD5加密和解密。

首先，我们需要确定要加密的数据，然后创建一个MessageDigest对象并将其初始化为使用MD5算法。

接下来，通过调用update()方法将数据传递给MessageDigest对象，并使用digest()方法获得加密后的结果。

下面是一个使用Java MD5算法加密的示例：javaimport java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class MD5Example {public static void main(String[] args) {String data = "Hello, World!";String encryptedData = encryptMD5(data);System.out.println("Encrypted data: " + encryptedData);}public static String encryptMD5(String data) {try {MessageDigest md =MessageDigest.getInstance("MD5");md.update(data.getBytes());byte[] encryptedBytes = md.digest();StringBuilder sb = new StringBuilder();for (byte b : encryptedBytes) {sb.append(String.format("02x", b & 0xff));}return sb.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}return null;}}在上面的示例中，我们定义了一个名为MD5Example的类，其中包含了一个名为encryptMD5的静态方法。

java中rsa解密的方法（实用版3篇）《java中rsa解密的方法》篇1Java 中RSA 解密的方法可以通过以下步骤实现：1. 首先，需要生成RSA 密钥对，包括公钥和私钥。

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

2. 使用生成的公钥进行加密，得到加密后的密文。

3. 使用生成的私钥进行解密，得到原始明文。

具体的实现过程可以参考下面的代码片段：```javaimport java.security.KeyGenerator;import java.security.PrivateKey;import java.security.PublicKey;import java.security.RSAPrivateKey;import java.security.RSAPublicKey;import javax.crypto.Cipher;import javax.crypto.spec.EncryptionSpec;import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;public class RSA {public static void main(String[] args) {// 生成RSA 密钥对KeyGenerator keyGen = KeyGenerator.getInstance("RSA"); RSAKeyGenerator rsaKeyGen = (RSAKeyGenerator) keyGen; rsaKeyGen.init(2048); // 密钥长度为2048 位PublicKey publicKey = rsaKeyGen.generatePublic();PrivateKey privateKey = rsaKeyGen.generatePrivate();// 使用公钥进行加密byte[] plainText = "Hello, world!".getBytes();byte[] cipherText = encrypt(plainText, publicKey);// 使用私钥进行解密byte[] plainText2 = decrypt(cipherText, privateKey);System.out.println("解密后的明文为：" + new String(plainText2)); }// 加密数据public static byte[] encrypt(byte[] plainText, PublicKey publicKey) { try {Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] cipherText = cipher.doFinal(plainText);return cipherText;} catch (Exception e) {e.printStackTrace();return null;}}// 解密数据public static byte[] decrypt(byte[] cipherText, PrivateKey privateKey) {try {Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");cipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] plainText = cipher.doFinal(cipherText);return plainText;} catch (Exception e) {e.printStackTrace();return null;}}}```在以上代码中，首先通过KeyGenerator 类生成RSA 密钥对，然后使用生成的公钥进行加密，得到加密后的密文。

java中sha256加解密方法SHA256是一种常用的加密算法，它可以对数据进行加密和解密操作。

在Java中，我们可以使用Java的安全库提供的功能来实现SHA256的加解密。

我们需要导入Java的安全库，这可以通过在代码中添加以下语句来实现：```import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;```接下来，我们需要定义一个方法来实现SHA256的加密功能，可以命名为sha256Encrypt。

该方法接受一个字符串作为参数，并返回一个加密后的字符串。

具体代码如下：```public static String sha256Encrypt(String input) {try {MessageDigest digest = MessageDigest.getInstance("SHA-256");byte[] hash = digest.digest(input.getBytes("UTF-8"));StringBuilder hexString = new StringBuilder();for (byte b : hash) {String hex = Integer.toHexString(0xff & b);if (hex.length() == 1) hexString.append('0');hexString.append(hex);}return hexString.toString();} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {e.printStackTrace();}return null;}```在这个方法中，我们首先通过调用MessageDigest.getInstance("SHA-256")来获取SHA-256算法的实例。

JAVA加密解密DES对称加密算法1下⾯⽤DES对称加密算法（设定⼀个密钥，然后对所有的数据进⾏加密）来简单举个例⼦。

23⾸先，⽣成⼀个密钥KEY。

4我把它保存到key.txt中。

这个⽂件就象是⼀把钥匙。

谁拥有它，谁就能解开我们的类⽂件。

代码参考如下：5package com.neusoft.jiami;6import Java.io.File;7import java.io.FileOutputStream;8import java.security.SecureRandom;9import javax.crypto.KeyGenerator;10import javax.crypto.SecretKey;11class Key {12private String keyName;13public Key(String keyName) {14this.keyName = keyName;15 }16public void createKey(String keyName) throws Exception {17// 创建⼀个可信任的随机数源，DES算法需要18 SecureRandom sr = new SecureRandom();19// ⽤DES算法创建⼀个KeyGenerator对象20 KeyGenerator kg = KeyGenerator.getInstance("DES");21// 初始化此密钥⽣成器,使其具有确定的密钥长度22 kg.init(sr);23// ⽣成密匙24 SecretKey key = kg.generateKey();25// 获取密钥数据26byte rawKeyData[] = key.getEncoded();27// 将获取到密钥数据保存到⽂件中，待解密时使⽤28 FileOutputStream fo = new FileOutputStream(new File(keyName));29 fo.write(rawKeyData);30 }31public static void main(String args[]) {32try {33new Key("key.txt");34 } catch (Exception e) {35 e.printStackTrace();36 }37 }38 }39第⼆步，对我们所要进⾏加密的类⽂件进⾏加密。

java国密加密与解密流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。

文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 引入国密相关的依赖库在 Java 项目中，需要引入国密相关的依赖库，例如 Bouncy Castle 库。

在Java中，数据库密码解密的方法通常涉及使用安全的加密算法对存储的加密密码进行解密。

以下是一种常见的解密方法：1.使用加密算法对密码进行加密：在连接数据库之前，可以使用一种安全的加密算法（如AES或RSA）对密码进行加密，并将加密后的密码存储在配置文件或数据库中。

确保在此过程中，使用了安全的密钥管理和存储方法，以防止密码泄露。

2.在应用程序中使用解密算法解密密码：在应用程序中，您可以使用相应的解密算法以及正确的密钥来解密数据库密码。

以下是一种简单的示例：import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;public class DatabasePasswordDecryptor {private static final String ENCRYPTION_KEY ="YourEncryptionKey";/ / 替换为加密密钥public static String decrypt(String encryptedPassword)throws Excep tion{byte[] decodedKey = Base64.getDecoder().decode(ENCRYPTION_KEY);SecretKeySpec keySpec =new SecretKeySpec(decodedKey,"AES");Cipher cipher =Cipher.getInstance("AES");cipher.init(Cipher.DECRYPT_MODE, keySpec);byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(en cryptedPassword));return new String(decrypted);}public static void main(String[] args){try{String encryptedPassword ="YourEncryptedPassword";// 替换为加密密码String decryptedPassword =decrypt(encryptedPassword);System.out.println("Decrypted Password: "+ decryptedPasswo rd);}catch(Exception e){e.printStackTrace();}}}在这个例子中，需要替换ENCRYPTION_KEY和encryptedPassword为实际的加密密钥和加密后的密码。

java 实现浮点数字加密和减密的方法文章标题：深入探讨Java实现浮点数字加密和解密的方法一、引言在现代信息时代，数据加密和解密变得越来越重要。

而对于浮点数数据的加密和解密，尤为关键。

本文将从Java语言的角度，探讨如何实现对浮点数进行加密和解密的方法。

二、浮点数字加密的实现方法1. 对浮点数进行位运算在Java中，可以通过位运算的方式对浮点数进行加密。

通过对浮点数的二进制表示进行位运算，可以实现加密的目的。

可以使用异或操作对浮点数的二进制位进行加密，从而保护数据的安全性。

2. 使用加密算法对浮点数进行处理Java中提供了丰富的加密算法库，可以通过这些算法对浮点数进行加密处理。

可以使用MD5、SHA等哈希算法对浮点数进行加密，实现数据的安全存储和传输。

3. 自定义加密算法除了使用Java已有的加密算法外，也可以自定义加密算法对浮点数进行加密。

通过与他人不可知的复杂算法，可以更好地保护浮点数数据的安全性。

三、浮点数字解密的实现方法1. 逆向位运算对于使用位运算进行浮点数加密的情况，可以通过进行逆向位运算的方式进行解密。

通过与加密时相反的位运算，可以还原出原始的浮点数数据。

2. 使用解密算法对浮点数进行处理与加密算法类似，Java中同样提供了丰富的解密算法库。

可以通过这些算法对加密过的浮点数进行解密，获取原始数据。

3. 自定义解密算法倘若使用了自定义的加密算法，那么也需要相应的自定义解密算法。

通过对加密过的浮点数数据进行逆向运算，可以实现解密的目的。

四、个人观点和理解在实际项目中，对浮点数进行加密和解密是一项非常重要的任务。

通过对浮点数数据进行加密，可以有效地保护数据的安全性，防止数据被未经授权的访问。

合理的加密和解密算法的选择，也是保证系统数据安全的重要一环。

总结与回顾通过本文的介绍，我们了解到了Java实现浮点数加密和解密的方法。

无论是通过位运算、使用加密算法，还是自定义加密算法，都可以实现对浮点数数据的安全处理。

java enc解密方法在Java中，可以使用Java内置的加密和解密库来实现加密和解密操作。

以下是一个简单的示例，演示如何使用Java内置的加密和解密库进行加密和解密操作：```javaimport ;import ;import ;import ;public class EncryptionExample {public static void main(String[] args) throws Exception {// 原始字符串String original = "Hello, World!";// 加密密钥String key = "secretkey";// 加密操作Cipher cipher = ("AES/ECB/PKCS5Padding");SecretKeySpec secretKey = new SecretKeySpec((_8), "AES");(_MODE, secretKey);byte[] encrypted = ((_8));String encryptedString = ().encodeToString(encrypted);("加密后的字符串: " + encryptedString);// 解密操作(_MODE, secretKey);byte[] decrypted = (().decode(encryptedString));String decryptedString = new String(decrypted, _8);("解密后的字符串: " + decryptedString);}}```在这个示例中，我们使用AES算法进行加密和解密操作。

我们首先定义了一个原始字符串和加密密钥。

然后，我们使用Cipher类创建一个加密对象，并使用指定的算法和模式进行初始化。

javasm4国密算法加密、解密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 java.security.Key;import java.security.NoSuchAlgorithmException;import java.security.NoSuchProviderException;import java.security.SecureRandom;import java.security.Security;import java.util.Arrays;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.spec.SecretKeySpec;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;/*** sm4加密算法⼯具类* @explain sm4加密、解密与加密结果验证* 可逆算法* @author Marydon* @creationTime 2018年7⽉6⽇上午11:46:59* @version 1.0* @since*@*****************************/public class Sm4Util {static {Security.addProvider(new BouncyCastleProvider());}private static final String ENCODING = "UTF-8";public static final String ALGORITHM_NAME = "SM4";// 加密算法/分组加密模式/分组填充⽅式// PKCS5Padding-以8个字节为⼀组进⾏分组加密// 定义分组加密模式使⽤：PKCS5Paddingpublic static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";// 128-32位16进制；256-64位16进制public static final int DEFAULT_KEY_SIZE = 128;/*** ⽣成ECB暗号* @explain ECB模式（电⼦密码本模式：Electronic codebook）* @param algorithmName* 算法名称* @param mode* 模式* @param key* @return* @throws Exception*/private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);cipher.init(mode, sm4Key);return cipher;}}2.SM4加密 第⼀步：产⽣密钥 ⽅式⼀：系统⽣成密钥/*** ⾃动⽣成密钥* @explain* @return* @throws NoSuchAlgorithmException* @throws NoSuchProviderException*/public static byte[] generateKey() throws Exception {return generateKey(DEFAULT_KEY_SIZE);}/*** @explain* @param keySize* @returnpublic static byte[] generateKey(int keySize) throws Exception {KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME); kg.init(keySize, new SecureRandom());return kg.generateKey().getEncoded();} ⽅法⼆：⾃⼰提供16进制的密钥 第⼆步：加密/*** sm4加密* @explain 加密模式：ECB* 密⽂长度不固定，会随着被加密字符串长度的变化⽽变化* @param hexKey* 16进制密钥（忽略⼤⼩写）* @param paramStr* 待加密字符串* @return 返回16进制的加密字符串* @throws Exception*/public static String encryptEcb(String hexKey, String paramStr) throws Exception {String cipherText = "";// 16进制字符串-->byte[]byte[] keyData = ByteUtils.fromHexString(hexKey);// String-->byte[]byte[] srcData = paramStr.getBytes(ENCODING);// 加密后的数组byte[] cipherArray = encrypt_Ecb_Padding(keyData, srcData);// byte[]-->hexStringcipherText = ByteUtils.toHexString(cipherArray);return cipherText;}/*** 加密模式之Ecb* @explain* @param key* @param data* @return* @throws Exception*/public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data) throws Exception {Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);return cipher.doFinal(data);}3.SM4解密/*** sm4解密* @explain 解密模式：采⽤ECB* @param hexKey* 16进制密钥* @param cipherText* 16进制的加密字符串（忽略⼤⼩写）* @return 解密后的字符串* @throws Exception*/public static String decryptEcb(String hexKey, String cipherText) throws Exception {// ⽤于接收解密后的字符串String decryptStr = "";// hexString-->byte[]byte[] keyData = ByteUtils.fromHexString(hexKey);// hexString-->byte[]byte[] cipherData = ByteUtils.fromHexString(cipherText);// 解密byte[] srcData = decrypt_Ecb_Padding(keyData, cipherData);// byte[]-->StringdecryptStr = new String(srcData, ENCODING);return decryptStr;}/*** 解密* @explain* @param key* @param cipherText* @return* @throws Exception*/public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText) throws Exception {Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);return cipher.doFinal(cipherText);} 4.加密数据校验/*** 校验加密前后的字符串是否为同⼀数据* @explain* @param hexKey* 16进制密钥（忽略⼤⼩写）* @param cipherText* 16进制加密后的字符串* @param paramStr* 加密前的字符串* @return 是否为同⼀数据。

java中decrypt和encrypt方法在Java中，加密（encrypt）和解密（decrypt）是非常常见和重要的操作。

加密是将明文数据转换为密文数据，以保护数据的安全性。

而解密是将密文数据重新转换为明文数据，以便于使用和理解。

本文将介绍Java中的加密和解密方法，包括常见的加密算法和使用示例。

在Java中，加密和解密操作通常使用加密算法来完成。

常用的加密算法包括对称加密和非对称加密。

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

常见的对称加密算法有DES（Data Encryption Standard）、AES（Advanced Encryption Standard）等。

其中，AES是目前最常用和最安全的对称加密算法。

对称加密的特点是速度快，但密钥的传输和管理相对较复杂。

非对称加密是一种使用两个不同的密钥进行加密和解密的算法，分别为公钥和私钥。

公钥用于加密数据，私钥用于解密数据。

常见的非对称加密算法有RSA（Rivest-Shamir-Adleman）、DSA（DigitalSignature Algorithm）等。

非对称加密的特点是安全性较高，但速度相对较慢。

下面是一些常用的加密和解密方法的示例：1.对称加密：对称加密的示例中，我们使用AES算法和密钥来加密和解密数据。

```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import java.security.SecureRandom;public class SymmetricEncryptionExample {public static void main(String[] args) throws Exception { //生成AES密钥KeyGenerator keyGenerator =KeyGenerator.getInstance("AES");keyGenerator.init(128, new SecureRandom());SecretKey secretKey = keyGenerator.generateKey();//创建加密和解密的实例Cipher cipher = Cipher.getInstance("AES");//加密数据String plainText = "Hello, World!";cipher.init(Cipher.ENCRYPT_MODE, secretKey);byte[] encryptedText =cipher.doFinal(plainText.getBytes());System.out.println("加密后的数据：" + newString(encryptedText));//解密数据cipher.init(Cipher.DECRYPT_MODE, secretKey);byte[] decryptedText = cipher.doFinal(encryptedText);System.out.println("解密后的数据：" + newString(decryptedText));}}```在上面的示例中，我们首先使用AES算法生成一个128位的密钥。

java接收文件加密解密方法
在Java中接收加密文件并进行解密可以通过多种方式实现。

下面我将从多个角度介绍几种常见的方法：
1. 使用对称加密算法：
可以使用Java的javax.crypto包中的类来实现对称加密算法，如AES。

首先，接收加密文件后，可以使用FileInputStream 读取文件内容，然后使用Cipher类进行解密操作，最后使用FileOutputStream将解密后的内容写入新文件。

2. 使用非对称加密算法：
如果发送方使用了公钥加密文件，接收方可以使用私钥进行解密。

可以使用Java的java.security包中的类来实现非对称加密算法，如RSA。

首先，接收加密文件后，可以使用PrivateKey类进行解密操作，最后使用FileOutputStream将解密后的内容写入新文件。

3. 使用第三方库：
除了Java自带的加密算法外，也可以使用第三方库来简化加密解密操作，例如Bouncy Castle或者Apache Commons Crypto 等。

这些库提供了更多的加密选项和更简单的API，可以更容易地实现文件的加密和解密操作。

无论使用哪种方法，都需要注意文件的安全传输和存储，以及密钥的安全管理。

另外，要确保在解密文件时处理可能出现的异常情况，如文件损坏或者密码错误等。

希望这些信息能够帮助你实现在Java中接收文件并进行加密解密的操作。

java使⽤RSA与AES加密解密⾸先了解下，什么是堆成加密，什么是⾮对称加密？ 对称加密：加密与解密的密钥是相同的，加解密速度很快，⽐如AES ⾮对称加密：加密与解密的秘钥是不同的，速度较慢，⽐如RSA先看代码（先会⽤在研究） 相关依赖： <dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>1，RSA⼯具类：package cn.wangtao.utils;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.crypto.Cipher;import java.io.ByteArrayOutputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectOutputStream;import java.security.*;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;/*** @ClassName RSAUtils* @Auth 桃⼦* @Date 2019-6-25 15:15* @Version 1.0* @Description**/public class RSAUtils {private static final String RSA = "RSA"; // 加密⽅式private static final Logger logger= LoggerFactory.getLogger(RSAUtils.class);//获取密钥public static KeyPair getKey() throws Exception {try {KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA, new BouncyCastleProvider()); keyPairGenerator.initialize(2048); // 初始化密钥长度KeyPair keyPair = keyPairGenerator.generateKeyPair();// ⽣成密钥对return keyPair;} catch (Exception e) {logger.error("获取RSA秘钥对异常",e);throw new Exception("获取RSA秘钥对异常",e);}}//利⽤公钥进⾏加密public static String encryptStr(RSAPublicKey publicKey, String str) throws Exception {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.ENCRYPT_MODE, publicKey);//加密byte[] bytes = getBytes(str.getBytes(), cipher);//2进⾏转换成16进制String result = CommonUtils.parseByte2HexStr(bytes);return result;} catch (Exception e) {logger.error("使⽤RSA公钥进⾏加密异常",e);throw new Exception("使⽤RSA公钥进⾏加密异常",e);}}//利⽤私钥进⾏解密public static String decryptStr(RSAPrivateKey privateKey, String str) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.DECRYPT_MODE, privateKey); // ⽤密钥初始化此Cipher对象//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(str);//解密byte[] bs = getBytes(bytes, cipher);String content=new String(bs,"utf-8");return content;} catch (Exception e) {logger.error("使⽤RSA私钥进⾏解密异常",e);throw new Exception("使⽤RSA私钥进⾏解密异常",e);}}//通过cipher获取字节数组public static byte[] getBytes(byte[] bytes,Cipher cipher) throws Exception {int blockSize = cipher.getBlockSize(); // 返回块的⼤⼩int j = 0;ByteArrayOutputStream baos = new ByteArrayOutputStream();while (bytes.length - j * blockSize > 0) { // 将⼆进制数据分块写⼊ByteArrayOutputStream中 if(bytes.length-j*blockSize>blockSize){baos.write(cipher.doFinal(bytes, j * blockSize, blockSize));}else{baos.write(cipher.doFinal(bytes, j * blockSize,bytes.length-j*blockSize));}j++;}baos.close();byte[] byteArray = baos.toByteArray();return byteArray;}//保存秘钥对到⽂件public void saveRSAKey(String fileName) throws Exception {FileOutputStream fos=null;ObjectOutputStream oos=null;try {KeyPair keyPair = getKey();fos=new FileOutputStream(fileName);oos=new ObjectOutputStream(fos); //对象序列号oos.writeObject(keyPair);} catch (Exception e) {logger.error("RSA秘钥对保存到⽂件异常[{}]",fileName,e);throw new Exception("RSA秘钥对保存到⽂件异常",e);}finally {if(oos!=null){try {oos.close();} catch (IOException e1) {e1.printStackTrace();}if(fos!=null){try {fos.close();} catch (IOException e1) {e1.printStackTrace();}}}}}/*** @ClassName RSAUtils* @Version 1.0* @Description RSA⼯具类**/public class RSAUtils {private static final String RSA = "RSA";public static final String MD5WITHRSA="MD5withRSA";public static final String SHA1WITHRSA="SHA1withRSA";private static Logger logger= LoggerFactory.getLogger(RSAUtils.class);/*** @desc 读取秘钥⽂本内容* @createTime 2019年7⽉2⽇下午5:20:38* @param keyFile 秘钥⽂件* @return 秘钥⽂本内容* @throws Exception*/private static String initKeyByFile(File keyFile) throws Exception {if(keyFile.exists() && keyFile.isFile()) {BufferedReader bufferedReader = null;try {bufferedReader = new BufferedReader(new FileReader(keyFile));StringBuilder stringBuilder = new StringBuilder();String line = null;while ((line = bufferedReader.readLine()) != null) {if (line.length() == 0 || line.charAt(0) == '-') {continue;}stringBuilder.append(line).append(System.getProperty("line.separator")); }return stringBuilder.toString();}catch (Exception e) {logger.error("读取秘钥⽂本内容异常",e);throw new Exception("读取秘钥⽂本内容异常",e);}finally {CommonUtils.closeReaderandWriter(bufferedReader, null);}}return null;}/*** @desc 获取公钥* @author Liuweian* @createTime 2019年7⽉2⽇下午5:19:34* @param pubKeyFileName 公钥⽂件地址* @return PublicKey* @throws Exception*/public static PublicKey getPublicKeyByFile(File pubKeyFile) throws Exception {String keyContent = initKeyByFile(pubKeyFile);byte[] keyByte = Base64.decode(keyContent);KeyFactory kf = KeyFactory.getInstance(RSA);X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyByte);return kf.generatePublic(keySpec);}* @desc 获取私钥* @createTime 2019年7⽉2⽇下午5:19:16* @param priKeyFileName 私钥⽂件地址* @return PrivateKey* @throws Exception*/public static PrivateKey getPrivateKeyByFile(File priKeyFile) throws Exception {String keyContent = initKeyByFile(priKeyFile);byte[] keyByte = Base64.decode(keyContent);KeyFactory kf = KeyFactory.getInstance(RSA);PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyByte);return kf.generatePrivate(keySpec);}/*** @desc 使⽤RSA中的私钥对数据签名* @createTime 2019年7⽉2⽇下午5:24:30* @param privateKey 秘钥对中的私钥* @param data 待加签字节数组* @param signType 加签类型* @return 加签后的签名* @throws Exception*/public static String sign(byte[] data, PrivateKey privateKey, String signType) throws Exception {Signature signature = Signature.getInstance(signType);signature.initSign(privateKey);signature.update(data);byte[] signByte = signature.sign();//Base64加密return new String(Base64.encode(signByte));}/*** @desc 使⽤RSA中的公钥对签名验签* @createTime 2019年7⽉2⽇下午5:24:30* @param data 待验签字节数组* @param sign 签名* @param publicKey 秘钥对中的公钥* @param signType 加签类型* @return 验签是否成功* @throws Exception*/public static boolean verify(byte[] data, byte[] sign, PublicKey publicKey, String signType) {try {Signature signature = Signature.getInstance(signType);signature.initVerify(publicKey);signature.update(data);//Base64解密byte[] keyByte = Base64.decode(sign);return signature.verify(keyByte);} catch (Exception e) {logger.error("验签出现异常", e);return false;}}/*** @desc 使⽤RSA中的私钥对数据签名加签⽅式 MD5withRSA* @createTime 2019年7⽉2⽇下午5:24:30* @param privateKey 秘钥对中的私钥* @param data 待加签字节数组* @return 加签后的签名* @throws Exception*/public static String signMD5withRSA(byte[] data, PrivateKey privateKey) throws Exception {return sign(data, privateKey, MD5WITHRSA);}/*** @desc 使⽤RSA中的公钥对签名验签验签⽅式 MD5withRSA* @createTime 2019年7⽉2⽇下午5:24:30* @param sign 签名* @param publicKey 秘钥对中的公钥* @param signType 加签类型* @return 验签是否成功，失败则异常抛出* @throws Exception*/public static void verifyMD5withRSA(byte[] data, byte[] sign, PublicKey publicKey) throws Exception { if(!verify(data, sign, publicKey, MD5WITHRSA)) {throw new Exception("验签失败");}}/*** @desc 通过cipher获取字节数组分块* @createTime 2019年7⽉2⽇下午5:21:33* @param data 待加密的字节数组* @param cipher* @return* @throws Exception*/public static byte[] getBytes(byte[] data, Cipher cipher) throws Exception {int blockSize = cipher.getBlockSize(); // 返回块的⼤⼩int j = 0;ByteArrayOutputStream baos = new ByteArrayOutputStream();while (data.length - j * blockSize > 0) { // 将⼆进制数据分块写⼊ByteArrayOutputStream中 if(data.length - j * blockSize > blockSize) {baos.write(cipher.doFinal(data, j * blockSize, blockSize));}else{baos.write(cipher.doFinal(data, j * blockSize, data.length - j * blockSize));}j++;}baos.close();byte[] byteArray = baos.toByteArray();return byteArray;}/*** @desc 利⽤公钥进⾏加密* @createTime 2019年7⽉2⽇下午5:24:30* @param key 密钥对的⼀个* @param data 待加密字节数组* @return 密⽂* @throws Exception*/public static String encrypt(Key key, byte[] data) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.ENCRYPT_MODE, key);//加密byte[] bytes = getBytes(data, cipher);//2进⾏转换成16进制String result = CommonUtils.parseByte2HexStr(bytes);return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));} catch (Exception e) {logger.error("使⽤RSA公钥进⾏加密异常",e);throw new Exception("使⽤RSA公钥进⾏加密异常",e);}}/*** @desc 利⽤私钥进⾏解密* @createTime 2019年7⽉2⽇下午5:23:10* @param key 密钥对的⼀个* @param data 待解密的字节数组* @return 明⽂* @throws Exception*/public static String decrypt(Key key, byte[] data) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.DECRYPT_MODE, key); // ⽤密钥初始化此Cipher对象//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));//解密byte[] bs = getBytes(bytes, cipher);String content=new String(bs,CommonUtils.CODE_TYPE);return content;} catch (Exception e) {logger.error("使⽤RSA私钥进⾏解密异常",e);throw new Exception("使⽤RSA私钥进⾏解密异常",e);}}}　2，CommonUtils通⽤⼯具类：package cn.wangtao.utils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.IOException;import java.io.Reader;import java.io.Writer;/*** @ClassName CommonUtils* @Auth 桃⼦* @Date 2019-6-27 12:51* @Version 1.0* @Description**/public class CommonUtils {private static final Logger logger= LoggerFactory.getLogger(CommonUtils.class);//编码⽅式public static final String CODE_TYPE = "UTF-8";//字符补全private static final String[] consult = new String[]{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","G"}; //关流public static void closeReaderandWriter(Reader reader, Writer writer){if(writer!=null){try {writer.close();} catch (IOException e) {logger.error("关闭输出流失败",e);}}if(reader!=null){try {reader.close();} catch (IOException e) {logger.error("关闭输出流失败",e);}}}//将16进制转换为⼆进制public static byte[] parseHexStr2Byte(String hexStr) {if (hexStr.length() < 1)return null;byte[] result = new byte[hexStr.length()/2];for (int i = 0;i< hexStr.length()/2; i++) {int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);result[i] = (byte) (high * 16 + low);}return result;}//将⼆进制转换成16进制public static String parseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i < buf.length; i++) {String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}return sb.toString();}//补全字符public static String completionCodeFor16Bytes(String str) throws Exception {try{int num = str.getBytes(CODE_TYPE).length;int index = num%16;//进⾏加密内容补全操作, 加密内容应该为 16字节的倍数, 当不⾜16*n字节是进⾏补全, 差⼀位时补全16+1位 //补全字符以 $ 开始,$后⼀位代表$后补全字符位数,之后全部以0进⾏补全;if(index != 0){StringBuffer sbBuffer = new StringBuffer(str);if(16-index == 1){sbBuffer.append("$" + consult[16-1] + addStr(16-1-1));}else{sbBuffer.append("$" + consult[16-index-1] + addStr(16-index-1-1));}str = sbBuffer.toString();}return str;}catch (Exception e){logger.error("使⽤AES加密前补全字符异常",e);throw new Exception("使⽤AES加密前补全字符异常",e);}}//追加字符public static String addStr(int num){StringBuffer sbBuffer = new StringBuffer("");for (int i = 0; i < num; i++) {sbBuffer.append("0");}return sbBuffer.toString();}//还原字符(进⾏字符判断)public static String resumeCodeOf16Bytes(String str) throws Exception{int indexOf = stIndexOf("$");if(indexOf == -1){return str;}String trim = str.substring(indexOf+1,indexOf+2).trim();int num = 0;for (int i = 0; i < consult.length; i++) {if(trim.equals(consult[i])){num = i;}}if(num == 0){return str;}return str.substring(0,indexOf).trim();}}3，AESUtils通⽤⼯具类：package cn.wangtao.utils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.io.*;import java.security.interfaces.RSAPrivateKey;import java.util.Map;/*** @ClassName AESUtils* @Auth 桃⼦* @Date 2019-6-27 12:05* @Version 1.0* @Description**/public class AESUtils {private static final Logger logger= LoggerFactory.getLogger(AESUtils.class);//填充类型public static final String AES_TYPE = "AES/ECB/PKCS5Padding";private static final String AES = "AES"; // 加密⽅式public static final String DES_TYPE = "DES/ECB/PKCS5Padding";private static final String DES = "DES"; // 加密⽅式private final String defaultDesKey="11112222";//8位//对字符串加密public static String encryptStr(String content,String aesKey) throws Exception {try {SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(),AES );Cipher cipher = Cipher.getInstance(AES_TYPE);cipher.init(Cipher.ENCRYPT_MODE, key);//字符补全String content16Str = pletionCodeFor16Bytes(content);byte[] encryptedData = cipher.doFinal(content16Str.getBytes(CommonUtils.CODE_TYPE));//2进制转换成16进制String hexStr = CommonUtils.parseByte2HexStr(encryptedData);return hexStr;} catch (Exception e) {logger.error("使⽤AES对字符串加密异常",e);throw new Exception("使⽤AES对字符串加密异常",e);}}//对字符串解密public static String decryptStr(String content,String aesKey) throws Exception {try {//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(content);SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(), AES);Cipher cipher = Cipher.getInstance(AES_TYPE);cipher.init(Cipher.DECRYPT_MODE, key);byte[] decryptedData = cipher.doFinal(bytes);String result=new String(decryptedData, CommonUtils.CODE_TYPE);//还原字符String orgResult = CommonUtils.resumeCodeOf16Bytes(result);return orgResult;} catch (Exception e) {logger.error("使⽤AES对字符串解密异常",e);throw new Exception("使⽤AES对字符串解密异常",e);}}//对⽂件加密public static File encryptFile(File orgFile, File encryptFile, Map<String,Object> context) throws Exception {("使⽤AES对⽂件加密开始，源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath()); BufferedReader br=null;BufferedWriter bw=null;try{//获取AESKEY ，如果没有为默认String aesKey = (String) context.get(Dirt.AES_KEY);br=new BufferedReader(new FileReader(orgFile));bw=(BufferedWriter)context.get(Dirt.BUFFEREDWRITER);if(null==bw){bw=new BufferedWriter(new FileWriter(encryptFile));}String len=null;while (null!=(len=br.readLine())){String encrypt= encryptStr(len,aesKey);bw.write(encrypt);bw.newLine();bw.flush();}("使⽤AES对⽂件加密结束，源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath());return encryptFile;}catch (Exception e){logger.error("使⽤AES对⽂件加密异常,源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath(),e);throw new Exception("使⽤AES对⽂件加密异常",e);}finally {CommonUtils.closeReaderandWriter(br,bw);}}//对⽂本解密，返回解密⽂件后的⽂件public static File decryptFile(File decryptfile, File encryptFile,Map<String,Object> context) throws Exception {("使⽤AES对⽂件解密开始，源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath());BufferedReader br=null;BufferedWriter bw=null;try{if(decryptfile.exists()){decryptfile.delete();}//边读边加密边写br=new BufferedReader(new FileReader(encryptFile));bw=new BufferedWriter(new FileWriter(decryptfile));String len=null;String aesKey=null;//判断是否加密RSAPrivateKey privateKey= (RSAPrivateKey) context.get(Dirt.RSAPRIVATEKEY);if(null!=privateKey){StringBuffer sb=new StringBuffer();while ((len=br.readLine())!=null){sb.append(len);if(len.equals("\n")||len.equals("")||len.equals("\r\n")||len.equals("\r")){aesKey=RSAUtils.decryptStr(privateKey,sb.toString());break;}}}if(null==aesKey){aesKey=(String) context.get(Dirt.AES_KEY);}("aesKey[{}]",aesKey);if(aesKey!=null){while ((len=br.readLine())!=null){String decrypt= decryptStr(len,aesKey);bw.write(decrypt);bw.flush();bw.newLine();}}("使⽤AES对⽂件解密结束，源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath()); return decryptfile;}catch (Exception e){logger.error("使⽤AES对⽂件解密异常,源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath(),e); throw new Exception("使⽤AES对⽂件解密异常",e);}finally {CommonUtils.closeReaderandWriter(br,bw);}}}/*** @ClassName AESUtils* @Version 1.0* @Description AES⼯具类**/public class AESUtils {private static final Logger logger = LoggerFactory.getLogger(AESUtils.class);/** 加密⽅式 */public static final String AES = "AES";public static final String AES_Type = "AES/ECB/PKCS5Padding";/*** @desc 随机⽣成AES加密秘钥* @createTime 2019年7⽉2⽇下午5:36:00* @return 随机的AES的秘钥串 16位* @throws Exception*/public static String getAesKey() {Random random = new Random();String result = "";for(int i = 0; i< 16; i++){String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";// 输出字母还是数字if( "char".equalsIgnoreCase(charOrNum) ) {// 输出是⼤写字母还是⼩写字母// int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;result += (char)(random.nextInt(26) + 65);} else {result += String.valueOf(random.nextInt(10));}}return result;}/*** @desc AES加密操作* @createTime 2019年7⽉2⽇下午5:30:33* @param data 待加密字节数组* @param aesKey 秘钥串* @return 密⽂* @throws Exception*/public static String encrypt(byte[] data, String aesKey) throws Exception {try {SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES); Cipher cipher = Cipher.getInstance(AES);cipher.init(Cipher.ENCRYPT_MODE, key);byte[] encryptedData = cipher.doFinal(data);//2进制转换成16进制并返回密⽂String result = CommonUtils.parseByte2HexStr(encryptedData);return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));} catch (Exception e) {logger.error("使⽤AES对字符串加密异常", e);throw new Exception("使⽤AES对字符串加密异常", e);}}/*** @desc AES解密操作* @createTime 2019年7⽉2⽇下午5:31:37* @param data 待解密字节数组* @param aesKey 秘钥串* @return 明⽂* @throws Exception*/public static String decrypt(byte[] data, String aesKey) throws Exception {try {// 16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES); Cipher cipher = Cipher.getInstance(AES);cipher.init(Cipher.DECRYPT_MODE, key);//执⾏解密byte[] decryptedData = cipher.doFinal(bytes);//还原字符并返回return new String(decryptedData, CommonUtils.CODE_TYPE);} catch (Exception e) {logger.error("使⽤AES对字符串解密异常", e);throw new Exception("使⽤AES对字符串解密异常", e);}}} 4，Dirt常量package cn.wangtao.utils;import java.security.interfaces.RSAPublicKey;/*** @ClassName Dirt* @Auth 桃⼦* @Date 2019-6-27 14:20* @Version 1.0* @Description**/public class Dirt {public static final String UPLOADFILEURL="uploadFileUrl";public static final String AES_KEY="aesKey";public static final String RSAPUBLICKEY="rsaPublicKey";public static final String RSAPRIVATEKEY="rsaPrivateKey";public final static String RETURNCODE="returnCode";public final static String RETURNMSG="returnMsg";public final static String FILENAME="fileName";public final static String ORGFILENAME="orgFileName";public final static String ENCRYPTFILE="encryptFile";public static final String BUFFEREDWRITER="bufferedWriter"; //是为了在原始⽂件中进⾏补充加密 //返回码public final static String SUCCESSCODE="000000";public final static String FAILEDCODE="999999";//加密⽂件所放的⽬录public final static String BASELOCALDIR="XXX"; //基本⽬录路径public final static String ENCRYPTLOCALDIR="encrypt"; //加密⽂件⽬录}AES的介绍RSA的介绍。

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的MD5盐值加密，Des加密解密和base64加密解密使⽤⽅法java⽀持md5盐值加密和des加密。

做项⽬时，某些模块添加加密功能可以提⾼⽤户个⼈信息安全性，防⽌信息泄露，其中des⽀持加密解密，MD5⽬前只⽀持加密（多⽤于⽤户登录密码验证，所以⽆需解密展⽰）。

⼀、MD5盐值加密1.在pom⽂件中导⼊相关jar包<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-core</artifactId><version>1.3.2</version></dependency>2.编写MD5类import org.apache.shiro.crypto.hash.SimpleHash;/*** 加密⼯具类* @author john**/public class MD5 {//加密类型private static String hashName="MD5";//加密次数private static int hashNum=1024;//pwd是需要加密的字符，salt是盐值（⾃定义），hashNum是加密次数，次数越多越安全public static Object getMD5(String pwd,String salt){Object obj=new SimpleHash(hashName, pwd, salt, hashNum);return obj;}}加密⽅法是静态⽅法，使⽤时直接MD5.getMD5（pwd,salt）.toString();即可。

暂⽆解密⽅法。

⼆、Base64加密1.同样第⼀步也是导⼊base相关jar包<!-- Base64 --><dependency><groupId>commons-codec</groupId><artifactId>commons-codec</artifactId><version>1.14</version></dependency>2.编写base64类import mons.codec.binary.Base64;public class Base64Utils {/*** 加密** @param plainText* @return*/public static String encodeStr(String plainText) {byte[] b = plainText.getBytes();Base64 base64 = new Base64();b = base64.encode(b);return new String(b);}/*** 解密** @param encodeStr* @return*/public static String decodeStr(String encodeStr) {byte[] b = encodeStr.getBytes();Base64 base64 = new Base64();b = base64.decode(b);return new String(b);}}加密解密的⽅法同样是静态⽅法，直接类名.⽅法名调⽤即可。

Java使⽤Hutool实现AES、DES加密解密的⽅法在Java世界中，AES、DES加密解密需要使⽤Cipher对象构建加密解密系统，Hutool中对这⼀对象做再包装，简化了加密解密过程。

介绍AES和DES同属对称加密算法，数据发信⽅将明⽂（原始数据）和加密密钥⼀起经过特殊加密算法处理后，使其变成复杂的加密密⽂发送出去。

收信⽅收到密⽂后，若想解读原⽂，则需要使⽤加密⽤过的密钥及相同算法的逆算法对密⽂进⾏解密，才能使其恢复成可读明⽂。

在对称加密算法中，使⽤的密钥只有⼀个，发收信双⽅都使⽤这个密钥对数据进⾏加密和解密，这就要求解密⽅事先必须知道加密密钥。

在Java世界中，AES、DES加密解密需要使⽤Cipher对象构建加密解密系统，Hutool中对这⼀对象做再包装，简化了加密解密过程。

引⼊Hutool<dependency><groupId>com.xiaoleilu</groupId><artifactId>hutool-all</artifactId><version>3.0.9</version></dependency>使⽤AES加密解密String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();//构建AES aes = SecureUtil.aes(key);//加密byte[] encrypt = aes.encrypt(content);//解密byte[] decrypt = aes.decrypt(encrypt);//加密为16进制表⽰String encryptHex = des.encryptHex(content);//解密为原字符串String decryptStr = des.decryptStr(encryptHex);DES加密解密DES的使⽤⽅式与AES基本⼀致String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue()).getEncoded();//构建DES des = SecureUtil.des(key);//加密解密byte[] encrypt = des.encrypt(content);byte[] decrypt = des.decrypt(encrypt);//加密为16进制，解密为原字符串String encryptHex = des.encryptHex(content);String decryptStr = des.decryptStr(encryptHex);更多Hutool中针对JDK⽀持的所有对称加密算法做了封装，封装为SymmetricCrypto类，AES和DES两个类是此类的简化表⽰。

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后台加密解密方法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。