java课设加密与解密

合集下载

java 密码加密解密方法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SpringBoot中_JAVA利用国密算法_实现内容的加密_解密

首先来看一下什么是国密算法:国密即国家密码局认定的国产密码算法，即商用密码。

国密主要有SM1，SM2，SM3，SM4。

密钥长度和分组长度均为128位。

1、SM1 为对称加密。

其加密强度与AES(高级加密标准,Advanced Encryption Standard)相当。

该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。

2、SM2为非对称加密，基于ECC。

该算法已公开。

由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。

ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比RSA 2048位高，但运算速度快于RSA。

3、SM3为消息摘要。

可以用MD5作为对比理解。

该算法已公开。

校验结果为256位。

4、SM4为无线局域网标准的分组数据算法。

对称加密，密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组大小为128bit，故对消息进行加解密时，若消息长度过长，需要进行分组，要消息长度不足，则要进行填充。

在很多地方还是会用到的,这里说一下这个:SM21.在pom.xml中引入依赖jar包:<dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>2.然后来写一个工具类,用来生成国密的,公钥和私钥这个密码对.import org.bouncycastle.jce.provider.BouncyCastleProvider;import java.security.*;import java.security.spec.ECGenParameterSpec;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.Base64;/*** @author hulala* @Description 国密公私钥对工具类public class KeyUtils {/*** 生成国密公私钥对** @return* @throws Exception*/public static String[] generateSmKey() throws Exception {KeyPairGenerator keyPairGenerator = null;SecureRandom secureRandom = new SecureRandom();ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");keyPairGenerator = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());keyPairGenerator.initialize(sm2Spec);keyPairGenerator.initialize(sm2Spec, secureRandom);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();PublicKey publicKey = keyPair.getPublic();//String[0] 公钥//String[1] 私钥String[] result = {new String(Base64.getEncoder().encode(publicKey.getEncoded())), new String(Base64.getEncoder().encode(privateKey.getEncoded())) };return result;}/*** 将Base64转码的公钥串，转化为公钥对象** @param publicKey* @return*/public static PublicKey createPublicKey(String publicKey) {PublicKey publickey = null;try {X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePublic(publicKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}/*** 将Base64转码的私钥串，转化为私钥对象** @param privateKey* @return*/public static PrivateKey createPrivateKey(String privateKey) {PrivateKey publickey = null;try {PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}}3.根据公钥和私钥工具类,生成的密钥对,对数据,进行加密和解密操作import org.bouncycastle.asn1.gm.GMObjectIdentifiers;import org.bouncycastle.crypto.InvalidCipherTextException;import org.bouncycastle.crypto.engines.SM2Engine;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;import org.bouncycastle.crypto.params.ParametersWithRandom;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.jce.spec.ECParameterSpec;import java.security.*;/*** @author hulala* @Description SM2实现工具类*/public class Sm2Util {static {Security.addProvider(new BouncyCastleProvider());}/*** 根据publicKey对原始数据data，使用SM2加密** @param data* @param publicKey* @return*/public static byte[] encrypt(byte[] data, PublicKey publicKey) {ECPublicKeyParameters localECPublicKeyParameters = null;if (publicKey instanceof BCECPublicKey) {BCECPublicKey localECPublicKey = (BCECPublicKey) publicKey;ECParameterSpec localECParameterSpec = localECPublicKey.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());localECPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(), localECDomainParameters);}SM2Engine localSM2Engine = new SM2Engine();localSM2Engine.init(true, new ParametersWithRandom(localECPublicKeyParameters, new SecureRandom()));byte[] arrayOfByte2;try {arrayOfByte2 = localSM2Engine.processBlock(data, 0, data.length);return arrayOfByte2;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 根据privateKey对加密数据encodedata，使用SM2解密** @param encodedata* @param privateKey* @return*/public static byte[] decrypt(byte[] encodedata, PrivateKey privateKey) {SM2Engine localSM2Engine = new SM2Engine();BCECPrivateKey sm2PriK = (BCECPrivateKey) privateKey;ECParameterSpec localECParameterSpec = sm2PriK.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());ECPrivateKeyParameters localECPrivateKeyParameters = new ECPrivateKeyParameters(sm2PriK.getD(),localECDomainParameters);localSM2Engine.init(false, localECPrivateKeyParameters);try {byte[] arrayOfByte3 = localSM2Engine.processBlock(encodedata, 0, encodedata.length);return arrayOfByte3;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 私钥签名** @param data* @param privateKey* @return* @throws Exception*/public static byte[] signByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception { Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initSign(privateKey);sig.update(data);byte[] ret = sig.sign();return ret;}/*** 公钥验签** @param data* @param publicKey* @param signature* @return* @throws Exception*/public static boolean verifyByPublicKey(byte[] data, PublicKey publicKey, byte[] signature) throws Exception {Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initVerify(publicKey);sig.update(data);boolean ret = sig.verify(signature);return ret;}}4.来测试一下,对数据进行加密解密import org.junit.Test;import java.util.Base64;/*** @author hulala* @Description Sm2Util 的测试类*/public class Sm2UtilTest {private String testStr = "wangjing";java.security.PublicKey publicKey = null;java.security.PrivateKey privateKey = null;@Testpublic void test() throws Exception {//生成公私钥对String[] keys = KeyUtils.generateSmKey();System.out.println("原始字符串：" + testStr);System.out.println("公钥：" + keys[0]);publicKey = KeyUtils.createPublicKey(keys[0]);System.out.println("私钥：" + keys[1]);privateKey = KeyUtils.createPrivateKey(keys[1]);System.out.println("");byte[] encrypt = Sm2Util.encrypt(testStr.getBytes(), publicKey);String encryptBase64Str = Base64.getEncoder().encodeToString(encrypt);System.out.println("加密数据：" + encryptBase64Str);byte[] decode = Base64.getDecoder().decode(encryptBase64Str);byte[] decrypt = Sm2Util.decrypt(decode, privateKey);System.out.println("解密数据：" + new String(decrypt));byte[] sign = Sm2Util.signByPrivateKey(testStr.getBytes(), privateKey);System.out.println("数据签名：" + Base64.getEncoder().encodeToString(sign));boolean b = Sm2Util.verifyByPublicKey(testStr.getBytes(), publicKey, sign);System.out.println("数据验签：" + b);}}5.这样就实现了利用国密,SM2进行加密解密了.。

使用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`方法用于对密文进行解密。

Java实现MD5加密及解密的代码实例分享

Java实现MD5加密及解密的代码实例分享基础：MessageDigest类的使⽤其实要在Java中完成MD5加密，MessageDigest类⼤部分都帮你实现好了，⼏⾏代码⾜矣：/*** 对字符串md5加密** @param str* @return*/import java.security.MessageDigest;public static String getMD5(String str) {try {// ⽣成⼀个MD5加密计算摘要MessageDigest md = MessageDigest.getInstance("MD5");// 计算md5函数md.update(str.getBytes());// digest()最后确定返回md5 hash值，返回值为8为字符串。

因为md5 hash值是16位的hex值，实际上就是8位的字符// BigInteger函数则将8位的字符串转换成16位hex值，⽤字符串来表⽰；得到字符串形式的hash值return new BigInteger(1, md.digest()).toString(16);} catch (Exception e) {throw new SpeedException("MD5加密出现错误");}}进阶：加密及解密类Java实现MD5加密以及解密类，附带测试类，具体见代码。

MD5加密解密类——MyMD5Util,代码如下package com.zyg.security.md5;import java.io.UnsupportedEncodingException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.util.Arrays;public class MyMD5Util {private static final String HEX_NUMS_STR="0123456789ABCDEF";private static final Integer SALT_LENGTH = 12;/*** 将16进制字符串转换成字节数组* @param hex* @return*/public static byte[] hexStringToByte(String hex) {int len = (hex.length() / 2);byte[] result = new byte[len];char[] hexChars = hex.toCharArray();for (int i = 0; i < len; i++) {int pos = i * 2;result[i] = (byte) (HEX_NUMS_STR.indexOf(hexChars[pos]) << 4| HEX_NUMS_STR.indexOf(hexChars[pos + 1]));}return result;}/*** 将指定byte数组转换成16进制字符串* @param b* @return*/public static String byteToHexString(byte[] b) {StringBuffer hexString = new StringBuffer();for (int i = 0; i < b.length; i++) {String hex = Integer.toHexString(b[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}hexString.append(hex.toUpperCase());}return hexString.toString();}/*** 验证⼝令是否合法* @param password* @param passwordInDb* @return* @throws NoSuchAlgorithmException* @throws UnsupportedEncodingException*/public static boolean validPassword(String password, String passwordInDb)throws NoSuchAlgorithmException, UnsupportedEncodingException {//将16进制字符串格式⼝令转换成字节数组byte[] pwdInDb = hexStringToByte(passwordInDb);//声明盐变量byte[] salt = new byte[SALT_LENGTH];//将盐从数据库中保存的⼝令字节数组中提取出来System.arraycopy(pwdInDb, 0, salt, 0, SALT_LENGTH);//创建消息摘要对象MessageDigest md = MessageDigest.getInstance("MD5");//将盐数据传⼊消息摘要对象md.update(salt);//将⼝令的数据传给消息摘要对象md.update(password.getBytes("UTF-8"));//⽣成输⼊⼝令的消息摘要byte[] digest = md.digest();//声明⼀个保存数据库中⼝令消息摘要的变量byte[] digestInDb = new byte[pwdInDb.length - SALT_LENGTH];//取得数据库中⼝令的消息摘要System.arraycopy(pwdInDb, SALT_LENGTH, digestInDb, 0, digestInDb.length); //⽐较根据输⼊⼝令⽣成的消息摘要和数据库中消息摘要是否相同if (Arrays.equals(digest, digestInDb)) {//⼝令正确返回⼝令匹配消息return true;} else {//⼝令不正确返回⼝令不匹配消息return false;}}/*** 获得加密后的16进制形式⼝令* @param password* @return* @throws NoSuchAlgorithmException* @throws UnsupportedEncodingException*/public static String getEncryptedPwd(String password)throws NoSuchAlgorithmException, UnsupportedEncodingException {//声明加密后的⼝令数组变量byte[] pwd = null;//随机数⽣成器SecureRandom random = new SecureRandom();//声明盐数组变量byte[] salt = new byte[SALT_LENGTH];//将随机数放⼊盐变量中random.nextBytes(salt);//声明消息摘要对象MessageDigest md = null;//创建消息摘要md = MessageDigest.getInstance("MD5");//将盐数据传⼊消息摘要对象md.update(salt);//将⼝令的数据传给消息摘要对象md.update(password.getBytes("UTF-8"));//获得消息摘要的字节数组byte[] digest = md.digest();//因为要在⼝令的字节数组中存放盐，所以加上盐的字节长度pwd = new byte[digest.length + SALT_LENGTH];//将盐的字节拷贝到⽣成的加密⼝令字节数组的前12个字节，以便在验证⼝令时取出盐 System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH);//将消息摘要拷贝到加密⼝令字节数组从第13个字节开始的字节System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length);//将字节数组格式加密后的⼝令转化为16进制字符串格式的⼝令return byteToHexString(pwd);}}测试类——Client,代码如下：package com.zyg.security.md5;import java.io.UnsupportedEncodingException;import java.security.NoSuchAlgorithmException;import java.util.HashMap;import java.util.Map;public class Client {private static Map users = new HashMap();public static void main(String[] args){String userName = "zyg";String password = "123";registerUser(userName,password);userName = "changong";password = "456";registerUser(userName,password);String loginUserId = "zyg";String pwd = "1232";try {if(loginValid(loginUserId,pwd)){System.out.println("欢迎登陆");}else{System.out.println("⼝令错误，请重新输⼊");}} catch (NoSuchAlgorithmException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (UnsupportedEncodingException e) {// TODO Auto-generated catch blocke.printStackTrace();}}/*** 注册⽤户** @param userName* @param password*/public static void registerUser(String userName,String password){String encryptedPwd = null;try {encryptedPwd = MyMD5Util.getEncryptedPwd(password);users.put(userName, encryptedPwd);} catch (NoSuchAlgorithmException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (UnsupportedEncodingException e) {// TODO Auto-generated catch blocke.printStackTrace();}}/*** 验证登陆** @param userName* @param password* @return* @throws UnsupportedEncodingException* @throws NoSuchAlgorithmException*/public static boolean loginValid(String userName,String password)throws NoSuchAlgorithmException, UnsupportedEncodingException{String pwdInDb = (String)users.get(userName);if(null!=pwdInDb){ // 该⽤户存在return MyMD5Util.validPassword(password, pwdInDb);}else{System.out.println("不存在该⽤户");return false;}}}PS：这⾥再为⼤家提供2款MD5加密⼯具，感兴趣的朋友可以参考⼀下：MD5在线加密⼯具：在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密⼯具：。

JAVA实现AES的加密和解密算法

JAVA实现AES的加密和解密算法AES（高级加密标准）是一种对称加密算法，可以通过Java的javax.crypto库来实现。

下面我们将介绍一种基于Java的AES加密和解密算法的实现方法。

1.导入所需的包在Java中使用AES加密和解密算法需要导入以下两个包：```import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;```2.创建加密和解密函数首先，我们需要创建加密函数和解密函数。

加密函数将输入的明文数据加密为密文，解密函数将输入的密文数据解密为明文。

```javaprivate static byte[] encrypt(byte[] key, byte[] data) throws ExceptionSecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);return cipher.doFinal(data);private static byte[] decrypt(byte[] key, byte[] encryptedData) throws ExceptionSecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);return cipher.doFinal(encryptedData);```3.测试加密和解密函数为了验证加密和解密函数的正确性，我们可以创建一个测试函数来测试它们。

javamd5加密和解密算法实例 -回复

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加解密

Java加解密⼀、概述 Jasypt 这个Java类包为开发⼈员提供⼀种简单的⽅式来为项⽬增加加密功能，包括：密码Digest认证，⽂本和对象加密，集成hibernate，Spring Security(Acegi)来增强密码管理。

Jasypt是⼀个Java库，可以使开发者不需太多操作来给Java项⽬添加基本加密功能，⽽且不需要知道加密原理。

根据Jasypt⽂档，该技术可⽤于加密任务与应⽤程序，例如加密密码、敏感信息和数据通信、创建完整检查数据的sums. 其他性能包括⾼安全性、基于标准的加密技术、可同时单向和双向加密的加密密码、⽂本、数字和⼆进制⽂件。

Jasypt也可以与Acegi Security整合也即Spring Security。

Jasypt亦拥有加密应⽤配置的集成功能，⽽且提供⼀个开放的API从⽽任何⼀个Java Cryptography Extension都可以使⽤Jasypt。

Jasypt还符合RSA标准的基于密码的加密，并提供了⽆配置加密⼯具以及新的、⾼可配置标准的加密⼯具。

1、该开源项⽬可⽤于加密任务与应⽤程序，例如加密密码、敏感信息和数据通信 2、还包括⾼安全性、基于标准的加密技术、可同时单向和双向加密的加密密码、⽂本、数字和⼆进制⽂件。

3、Jasypt还符合RSA标准的基于密码的加密，并提供了⽆配置加密⼯具以及新的、⾼可配置标准的加密⼯具。

4、加密属性⽂件（encryptable properties files）、Spring work集成、加密Hibernate数据源配置、新的命令⾏⼯具、URL加密的Apache wicket集成以及升级⽂档。

5、Jasypt也可以与Acegi Security整合也即Spring Security。

Jasypt亦拥有加密应⽤配置的集成功能，⽽且提供⼀个开放的API从⽽任何⼀个Java Cryptography Extension都可以使⽤Jasypt。

java课程设计凯撒加密解密

java课程设计凯撒加密解密一、教学目标本章节的教学目标旨在让学生掌握Java语言实现凯撒加密和解密的方法。

通过本章节的学习，学生应达到以下目标：1.知识目标：了解凯撒加密和解密的基本原理；掌握Java语言的基本语法和编程技巧；理解循环、条件语句在程序中的应用。

2.技能目标：能够使用Java语言编写简单的凯撒加密和解密程序；能够分析并解决程序中的错误和问题；能够协作完成编程任务，提高团队协作能力。

3.情感态度价值观目标：培养对计算机科学的兴趣和好奇心；培养学生的创新精神和实践能力；培养学生的团队合作意识和沟通能力。

二、教学内容本章节的教学内容主要包括以下几个部分：1.凯撒加密和解密的基本原理；2.Java语言的基本语法和编程技巧；3.循环、条件语句在程序中的应用；4.凯撒加密和解密程序的编写与调试。

第1课时：凯撒加密和解密的基本原理；第2课时：Java语言的基本语法和编程技巧；第3课时：循环、条件语句在程序中的应用；第4课时：凯撒加密和解密程序的编写与调试。

为了提高教学效果，本章节将采用以下教学方法：1.讲授法：讲解凯撒加密和解密的基本原理，以及Java语言的基本语法和编程技巧；2.案例分析法：分析典型的凯撒加密和解密案例，引导学生理解并掌握相关知识；3.实验法：让学生动手编写凯撒加密和解密程序，培养学生的实践能力；4.讨论法：学生进行小组讨论，分享编程心得，提高学生的团队协作能力。

四、教学资源为了支持教学内容和教学方法的实施，本章节将准备以下教学资源：1.教材：Java编程入门教程；2.参考书：Java语言程序设计；3.多媒体资料：凯撒加密和解密的案例视频；4.实验设备：计算机、网络环境。

五、教学评估本章节的教学评估将采用多元化的评价方式，以全面、客观地评价学生的学习成果。

评估内容包括：1.平时表现：通过课堂参与、提问、回答问题等环节，评估学生的学习态度和积极性；2.作业：布置相关的编程作业，评估学生的理解和应用能力；3.实验报告：评估学生在实验过程中的操作能力和解决问题的能力；4.考试：设置期末考试，检验学生对凯撒加密和解密知识的掌握程度。

java常用加密和解密工具类EncryptUtil.java

java常⽤加密和解密⼯具类EncryptUtil.java 1package cn.util;23import java.io.UnsupportedEncodingException;4import java.security.MessageDigest;5import java.security.NoSuchAlgorithmException;6import java.security.SecureRandom;78import javax.crypto.Cipher;9import javax.crypto.SecretKey;10import javax.crypto.SecretKeyFactory;11import javax.crypto.spec.DESKeySpec;1213/**14 * 加密⼯具类15 *16 * md5加密出来的长度是32位17 *18 * sha加密出来的长度是40位19 *20 * @author伍⽟林21 *22*/23public final class EncryptUtil {2425private static final String PASSWORD_CRYPT_KEY = "88444488";2627private final static String DES = "DES";2829/**30 * ⼆次加密先sha-1加密再⽤MD5加密31 *32 * @param src33 * @return34*/35public final static String md5AndSha(String src) {36return md5(sha(src));37 }3839/**40 * ⼆次加密先MD5加密再⽤sha-1加密41 *42 * @param src43 * @return44*/45public final static String shaAndMd5(String src) {46return sha(md5(src));47 }4849/**50 * md5加密51 *52 * @param src53 * @return54*/55public final static String md5(String src) {56return encrypt(src, "md5");57 }5859/**60 * sha-1加密61 *62 * @param src63 * @return64*/65public final static String sha(String src) {66return encrypt(src, "sha-1");67 }6869/**70 * md5或者sha-1加密71 *72 * @param src73 * 要加密的内容74 * @param algorithmName75 * 加密算法名称：md5或者sha-1，不区分⼤⼩写76 * @return77*/78private final static String encrypt(String src, String algorithmName) {79if (src == null || "".equals(src.trim())) {80throw new IllegalArgumentException("请输⼊要加密的内容");81 }82if (algorithmName == null || "".equals(algorithmName.trim())) {83 algorithmName = "md5";84 }85 String encryptText = null;86try {87 MessageDigest m = MessageDigest.getInstance(algorithmName);88 m.update(src.getBytes("UTF8"));89byte s[] = m.digest();90// m.digest(src.getBytes("UTF8"));91return hex(s);92 } catch (NoSuchAlgorithmException e) {93 e.printStackTrace();94 } catch (UnsupportedEncodingException e) {95 e.printStackTrace();96 }97return encryptText;98 }99100/**101 * 密码解密102 *103 * @param data104 * @return105 * @throws Exception106*/107public final static String decrypt(String src) {108try {109return new String(decrypt(hex2byte(src.getBytes()), PASSWORD_CRYPT_KEY.getBytes())); 110 } catch (Exception e) {111 }112return null;113 }114115/**116 * 密码加密117 *118 * @param password119 * @return120 * @throws Exception121*/122public final static String encrypt(String src) {123try {124return byte2hex(encrypt(src.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));125 } catch (Exception e) {126 }127return null;128 }129130/**131 * 加密132 *133 * @param src134 * 数据源135 * @param key136 * 密钥，长度必须是8的倍数137 * @return返回加密后的数据138 * @throws Exception139*/140private static byte[] encrypt(byte[] src, byte[] key) throws Exception {141// DES算法要求有⼀个可信任的随机数源142 SecureRandom sr = new SecureRandom();143// 从原始密匙数据创建DESKeySpec对象144 DESKeySpec dks = new DESKeySpec(key);145// 创建⼀个密匙⼯⼚，然后⽤它把DESKeySpec转换成⼀个SecretKey对象146 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);147 SecretKey securekey = keyFactory.generateSecret(dks);148// Cipher对象实际完成加密操作149 Cipher cipher = Cipher.getInstance(DES);150// ⽤密匙初始化Cipher对象151 cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);152// 现在，获取数据并加密正式执⾏加密操作153return cipher.doFinal(src);154 }155156/**157 * 解密158 *159 * @param src160 * 数据源161 * @param key162 * 密钥，长度必须是8的倍数163 * @return返回解密后的原始数据164 *165 * @throws Exception166*/167private final static byte[] decrypt(byte[] src, byte[] key) throws Exception {168// DES算法要求有⼀个可信任的随机数源169 SecureRandom sr = new SecureRandom();170// 从原始密匙数据创建⼀个DESKeySpec对象171 DESKeySpec dks = new DESKeySpec(key);172// 创建⼀个密匙⼯⼚，然后⽤它把DESKeySpec对象转换成⼀个SecretKey对象173 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);174 SecretKey securekey = keyFactory.generateSecret(dks);175// Cipher对象实际完成解密操作176 Cipher cipher = Cipher.getInstance(DES);177// ⽤密匙初始化Cipher对象178 cipher.init(Cipher.DECRYPT_MODE, securekey, sr);179// 现在，获取数据并解密正式执⾏解密操作180return cipher.doFinal(src);181 }182183private final static byte[] hex2byte(byte[] b) {184if ((b.length % 2) != 0)185throw new IllegalArgumentException("长度不是偶数");186byte[] b2 = new byte[b.length / 2];187for (int n = 0; n < b.length; n += 2) {188 String item = new String(b, n, 2);189 b2[n / 2] = (byte) Integer.parseInt(item, 16);190 }191return b2;192 }193194/**195 * ⼆⾏制转字符串196 *197 * @param b198 * @return199*/200private final static String byte2hex(byte[] b) {201 String hs = "";202 String stmp = "";203for (int n = 0; n < b.length; n++) {204 stmp = (ng.Integer.toHexString(b[n] & 0XFF));205if (stmp.length() == 1)206 hs = hs + "0" + stmp;207else208 hs = hs + stmp;209 }210return hs.toUpperCase();211 }212213/**214 * 返回⼗六进制字符串215 *216 * @param arr217 * @return218*/219private final static String hex(byte[] arr) {220 StringBuffer sb = new StringBuffer();221for (int i = 0; i < arr.length; ++i) {222 sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1, 3)); 223 }224return sb.toString();225 }226227 }。

java国密加密与解密流程

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 实现浮点数字加密和减密的方法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java语言课程设计题目（五篇模版）

Java语言课程设计题目（五篇模版）第一篇：Java语言课程设计题目Java语言课程设计设计目的：1、复习、巩固Java语言的基础知识，进一步加深对Java语言的理解和掌握；2、课程设计为学生提供了一个既动手又动脑，独立实践的机会，将课本上的理论知识和实际有机的结合起来，锻炼学生的分析解决实际问题的能力。

提高学生适应实际，实践编程的能力；3、培养学生在项目开发中团队合作精神、创新意识及能力。

设计要求：1、对系统进行功能模块分析、控制模块分析正确，符合课题要求，实现相应功能；可以加以其他功能或修饰，使程序更加完善、合理；2、标识符命名遵循Java命名规范，代码多加注释；3、注意各种可能遇到的异常处理，注重提高程序运行效率；4、系统设计要实用，编程简练，可用，功能全面；5、尽量使用图形界面实现，要符合日常软件使用规范来设计菜单和界面。

6、说明书、流程图要清楚；7、记录设计情况（备查，也为编写设计说明书作好准备）；8、要求采用模块化程序设计方法，及锯齿型书写格式（缩进格式），要求上机调试通过和按设计报告格式；9、上交课程设计软件代码、课程设计报告交老师保存。

另外要用A4打印一份上交。

设计时间：2012年-2013年第一学期第10周设计方式和安排：设计方式：学院实验室上机安排：布置题目；中期检查；验收考核内容和方式: 课程设计结束时，要求学生写出课程设计报告（附源程序），可运行的软件系统；课程设计成绩分两部分，设计报告占30％，设计作品占70％。

按照优秀、良好、中、及格，不及格五级给予成绩。

设计题目：（要求每个学生在下面题目中选择一个适合自己且感兴趣的题目独立完成，若需新知识一定要去查资料，如果自己有另外的感兴趣的项目，可以自己设计，但一定不能是随便下载一个应付，否则将定为不及格，且不给补答机会，切记）1、猜数游戏功能要求：计算机产生随机数，猜中即胜，猜不中，提示是大了还是小了，继续猜，直至猜到，给出所用时间和评语。

java enc解密方法

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类创建一个加密对象，并使用指定的算法和模式进行初始化。

java接收文件加密解密方法

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进行字符串加密解密算法

intiLen = arrB.length;
// 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
StringBuffer sb = newStringBuffer(iLen * 2);
for(inti = 0; i < iLen; i++) {
intintTmp = arrB[i];
privatestaticString strDefaultKey = "tourhb";
/** 加密工具 */
privateCipher encryptCipher = null;
/** 解密工具 */
privateCipher decryptCipher = null;
/**
* 将byte数组转换为表示16进制值的字符串，如：byte[]{8,18}转换为：0813，和public static byte[]
* hexStr2ByteArr(String strIn) 互为可逆的转换过程
*
* @param arrB
* 需要转换的byte数组
* @return 转换后的字符串
* @throws Exception
*
*/
publicstaticString byteArr2HexStr(byte[] arrB) throwsException {
arrB[i] = arrBTmp[i];
}
// 生成密钥
Key key = newjavax.crypto.spec.SecretKeySpec(arrB, "DES");
returnkey;
}
// 把负数转换为正数
while(intTmp < 0) {

JAVAAES加密与解密

}
其中的getKey()
public static Key getKey(String keySeed) { if (keySeed == null) { keySeed = System.getenv("AES_SYS_KEY"); } if (keySeed == null) { keySeed = System.getProperty("AES_SYS_KEY"); } if (keySeed == null || keySeed.trim().length() == 0) { keySeed = "abcd1234!@#$";// 默认种子 } try { SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG"); secureRandom.setSeed(keySeed.getBytes()); KeyGenerator generator = KeyGenerator.getInstance("AES"); generator.init(secureRandom); return generator.generateKey(); } catch (Exception e) { throw new RuntimeException(e); } }
AES/PCBC/PKCS5Padding 32 16 AES/PCBC/ISO10126Padding 32 16
可以看到，在原始数据长度为16的整数倍时，假如原始数据长度等于16*n，则使用NoPadding时加密后数据长度等于16*n，其它情况下加密数据长度等于16*(n+1)。在不足16的整数倍的情况下，假如原始数据长度等于16*n+m[其中m小于16]，除了NoPadding填充之外的任何方式，加密数据长度都等于16*(n+1)；NoPadding填充情况下，CBC、ECB和PCBC三种模式是不支持的，CFB、OFB两种模式下则加密数据长度等于原始数据长度。

java使用RSA与AES加密解密

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使用Hutool实现AES、DES加密解密的方法

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

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

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

在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后台加密解密方法在当今互联网安全领域中具有重要意义。

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

本文将介绍几种常见的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。

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

JA V A 程序设计报告----------------------------------------------------------------------------------------------------------------------------------------加密与解密辅导老师：冯艳君学号：1103050403姓名：卢雨情目录一课程设计总要求。

3 二题目及要求。

3三程序设计思路。

3 四程序代码。

10五总结。

17一课程设计总要求本次课程设计是对前面学过的所有面向对象的编程思想以及编程方法的一个总结、回顾和实践，因此，开始设计前学生一定要先回顾以前所学的内容，明确本次作业设计所要用到的技术点并到网上搜索以及查阅相关的书籍来搜集资料。

通过编写一个基于JA V A的应用系统综合实例，来掌握Java语言编程技巧。

二题目及要求加密与解密要求：采用图形用户界面1、给定任意一个文本文件，进行加密，生成另一个文件。

2、对加密后的文件还原。

三程序设计思路1 This method is called from within the constructor to initialize the form. WARNING: Do NOT modify this code. The content of this method isalways regenerated by the Form Editor.代码：public class FileEncrypterT extends javax.swing.JFrame {public static final int WIDTH = 550;public static final int HEIGHT = 200;2 加密函数输入：要加密的文件，密码（由0-F组成，共48个字符，表示3个8位的密码）如： AD67EA2F3BE6E5ADD368DFE03120B5DF92A8FD8FEC2F0746其中：AD67EA2F3BE6E5AD DES密码一D368DFE03120B5DF DES密码二92A8FD8FEC2F0746 DES密码三输出：对输入的文件加密后，保存到同一文件夹下增加了".tdes"扩展名的文件中。

代码：public static void main(String args[]) {FileEncrypter fe = new FileEncrypter();fe.show();}FileEncrypterT(){this.setSize(WIDTH,HEIGHT);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setResizable(false);Toolkit tk = Toolkit.getDefaultToolkit();Dimension screenSize = tk.getScreenSize();this.setLocation((screenSize.width - WIDTH)/2,(screenSize.height - HEIGHT)/2);this.setTitle("文件加密器(TriDES)");Container c = this.getContentPane();c.setLayout( new FlowLayout());final FilePanel fp = new FilePanel("文件选择");c.add(fp);final KeyPanel pp = new KeyPanel("密码");c.add(pp);JButton jbE = new JButton("加密");c.add(jbE);jbE.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent event){File file = new File(fp.getFileName());if (file.exists())encrypt(file.getAbsoluteFile(),pp.getKey());elseJOptionPane.showMessageDialog(null,"请选择文件！","提示",JOptionPane.OK_OPTION); }});JButton jbD = new JButton("解密");c.add(jbD);jbD.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent event){File file = new File(fp.getFileName());if (file.exists())decrypt(file.getAbsoluteFile(),pp.getKey());elseJOptionPane.showMessageDialog(null,"请选择文件！","提示",JOptionPane.OK_OPTION); }});}private void encrypt(File fileIn,String sKey){try{if(sKey.length() == 48){byte[] bytK1 = getKeyByStr(sKey.substring(0,16));byte[] bytK2 = getKeyByStr(sKey.substring(16,32));byte[] bytK3 = getKeyByStr(sKey.substring(32,48));FileInputStream fis = new FileInputStream(fileIn);byte[] bytIn = new byte[(int)fileIn.length()];for(int i = 0;i<fileIn.length();i++){bytIn[i] = (byte)fis.read();}//加密byte[] bytOut = encryptByDES(encryptByDES(encryptByDES(bytIn,bytK1),bytK2),bytK3);String fileOut = fileIn.getPath() + ".tdes";FileOutputStream fos = new FileOutputStream(fileOut);for(int i = 0;i<bytOut.length;i++){fos.write((int)bytOut[i]);}fos.close();JOptionPane.showMessageDialog(this,"加密成功！","提示",JOptionPane.OK_OPTION);}elseJOptionPane.showMessageDialog(this,"密码长度必须等于48！","错误信息",JOptionPane.ERROR_MESSAGE);}catch(Exception e){e.printStackTrace();}}3 解密函数输入：要解密的文件，密码（由0-F组成，共48个字符，表示3个8位的密码）如：AD67EA2F3BE6E5ADD368DFE03120B5DF92A8FD8FEC2F0746其中：AD67EA2F3BE6E5AD DES密码一D368DFE03120B5DF DES密码二92A8FD8FEC2F0746 DES密码三输出：对输入的文件解密后，保存到用户指定的文件中。

代码：private void decrypt(File fileIn,String sKey){try{if(sKey.length() == 48){String strPath = fileIn.getPath();if(strPath.substring(strPath.length()-5).toLowerCase().equals(".tdes"))strPath = strPath.substring(0,strPath.length()-5);else{JOptionPane.showMessageDialog(this,"不是合法的加密文件！","提示",JOptionPane.OK_OPTION);return;}JFileChooser chooser = new JFileChooser();chooser.setCurrentDirectory(new File("."));chooser.setSelectedFile(new File(strPath));//用户指定要保存的文件int ret = chooser.showSaveDialog(this);if(ret==JFileChooser.APPROVE_OPTION){byte[] bytK1 = getKeyByStr(sKey.substring(0,16));byte[] bytK2 = getKeyByStr(sKey.substring(16,32));byte[] bytK3 = getKeyByStr(sKey.substring(32,48));FileInputStream fis = new FileInputStream(fileIn);byte[] bytIn = new byte[(int)fileIn.length()];for(int i = 0;i<fileIn.length();i++){bytIn[i] = (byte)fis.read();}//解密byte[] bytOut = decryptByDES(decryptByDES(decryptByDES(bytIn,bytK3),bytK2),bytK1);File fileOut = chooser.getSelectedFile();fileOut.createNewFile();FileOutputStream fos = new FileOutputStream(fileOut);for(int i = 0;i<bytOut.length;i++){fos.write((int)bytOut[i]);}fos.close();JOptionPane.showMessageDialog(this,"解密成功！","提示",JOptionPane.OK_OPTION);}}elseJOptionPane.showMessageDialog(this,"密码长度必须等于48！","错误信息",JOptionPane.ERROR_MESSAGE);}catch(Exception e){JOptionPane.showMessageDialog(this,"解密失败，请核对密码！","提示",JOptionPane.OK_OPTION); }}4 用DES方法加密输入的字节bytKey需为8字节长，是加密的密码代码：private byte[] encryptByDES(byte[] bytP,byte[] bytKey) throws Exception{ DESKeySpec desKS = new DESKeySpec(bytKey);SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");SecretKey sk = skf.generateSecret(desKS);Cipher cip = Cipher.getInstance("DES");cip.init(Cipher.ENCRYPT_MODE,sk);return cip.doFinal(bytP);}5 用DES方法解密输入的字节bytKey需为8字节长，是解密的密码代码：private byte[] decryptByDES(byte[] bytE,byte[] bytKey) throws Exception{ DESKeySpec desKS = new DESKeySpec(bytKey);SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");SecretKey sk = skf.generateSecret(desKS);Cipher cip = Cipher.getInstance("DES");cip.init(Cipher.DECRYPT_MODE,sk);return cip.doFinal(bytE);}6 输入密码的字符形式，返回字节数组形式。