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实现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.测试加密和解密函数为了验证加密和解密函数的正确性，我们可以创建一个测试函数来测试它们。

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 加密解密简单实现

java 加密解密简单实现加密算法有很多种：这里只大约列举几例：1:消息摘要：（数字指纹）：既对一个任意长度的一个数据块进行计算，产生一个唯一指纹。

MD5/SHA1发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要，最后进行比较摘要是否相同。

2:单匙密码体制:DES:比较简便高效,密钥简短，加解密速度快，破译极其困难,但其安全性依赖于密匙的安全性。

DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。

DES算法的入口参数有三个：Key、Data、Mode。

其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。

当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。

代表：DSA4:非对称密匙密码体制（公匙体系）：加密密匙不同于解密密匙，加密密匙公之于众，谁都可以使用，解密密匙只有解密人自己知道。

代表：RSA下面是对上面几个例子进行的简单实现：Java代码1.package test;2.import java.io.FileInputStream;3.import java.io.FileOutputStream;4.import java.io.IOException;5.import java.io.ObjectInputStream;6.import java.io.ObjectOutputStream;7.import java.security.*;8.import javax.crypto.Cipher;9.import javax.crypto.KeyGenerator;10.import javax.crypto.SecretKey;11./**12. * 加密解密13. *14. * @author shy.qiu15. * @since /qiushyfm16. */17.public class CryptTest {18. /**19. * 进行MD5加密20. *21. * @param info22. * 要加密的信息23. * @return String 加密后的字符串24. */25. public String encryptToMD5(String info) {26. byte[] digesta = null;27. try {28. // 得到一个md5的消息摘要29. MessageDigest alga = MessageDigest.getInstance("MD5");30. // 添加要进行计算摘要的信息31. alga.update(info.getBytes());32. // 得到该摘要33. digesta = alga.digest();34. } catch (NoSuchAlgorithmException e) {35. e.printStackTrace();36. }37. // 将摘要转为字符串38. String rs = byte2hex(digesta);39. return rs;40. }41. /**42. * 进行SHA加密43. *44. * @param info45. * 要加密的信息46. * @return String 加密后的字符串47. */48. public String encryptToSHA(String info) {49. byte[] digesta = null;50. try {51. // 得到一个SHA-1的消息摘要52. MessageDigest alga = MessageDigest.getInstance("SHA-1");53. // 添加要进行计算摘要的信息54. alga.update(info.getBytes());55. // 得到该摘要56. digesta = alga.digest();57. } catch (NoSuchAlgorithmException e) {58. e.printStackTrace();59. }60. // 将摘要转为字符串61. String rs = byte2hex(digesta);62. return rs;63. }64. // //////////////////////////////////////////////////////////////////////////65. /**66. * 创建密匙67. *68. * @param algorithm69. * 加密算法,可用 DES,DESede,Blowfish70. * @return SecretKey 秘密（对称）密钥71. */72. public SecretKey createSecretKey(String algorithm) {73. // 声明KeyGenerator对象74. KeyGenerator keygen;75. // 声明密钥对象76. SecretKey deskey = null;77. try {78. // 返回生成指定算法的秘密密钥的 KeyGenerator 对象79. keygen = KeyGenerator.getInstance(algorithm);80. // 生成一个密钥81. deskey = keygen.generateKey();82. } catch (NoSuchAlgorithmException e) {83. e.printStackTrace();84. }85. // 返回密匙86. return deskey;87. }88. /**89. * 根据密匙进行DES加密90. *91. * @param key92. * 密匙93. * @param info94. * 要加密的信息95. * @return String 加密后的信息96. */97. public String encryptToDES(SecretKey key, String info) {98. // 定义加密算法,可用 DES,DESede,Blowfish99. String Algorithm = "DES";100. // 加密随机数生成器 (RNG),(可以不写)101. SecureRandom sr = new SecureRandom();102. // 定义要生成的密文103. byte[] cipherByte = null;104. try {105. // 得到加密/解密器106. Cipher c1 = Cipher.getInstance(Algorithm); 107. // 用指定的密钥和模式初始化Cipher对象108. // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE) 109. c1.init(Cipher.ENCRYPT_MODE, key, sr); 110. // 对要加密的内容进行编码处理,111. cipherByte = c1.doFinal(info.getBytes()); 112. } catch (Exception e) {113. e.printStackTrace();114. }115. // 返回密文的十六进制形式116. return byte2hex(cipherByte);117. }118. /**119. * 根据密匙进行DES解密120. *121. * @param key122. * 密匙123. * @param sInfo124. * 要解密的密文125. * @return String 返回解密后信息126. */127. public String decryptByDES(SecretKey key, String sInfo ) {128. // 定义加密算法,129. String Algorithm = "DES";130. // 加密随机数生成器 (RNG)131. SecureRandom sr = new SecureRandom();132. byte[] cipherByte = null;133. try {134. // 得到加密/解密器135. Cipher c1 = Cipher.getInstance(Algorithm); 136. // 用指定的密钥和模式初始化Cipher对象137. c1.init(Cipher.DECRYPT_MODE, key, sr); 138. // 对要解密的内容进行编码处理139. cipherByte = c1.doFinal(hex2byte(sInfo)); 140. } catch (Exception e) {141. e.printStackTrace();142. }143. // return byte2hex(cipherByte);144. return new String(cipherByte);145. }146. // /////////////////////////////////////////////////// //////////////////////////147. /**148. * 创建密匙组，并将公匙，私匙放入到指定文件中149. *150. * 默认放入mykeys.bat文件中151. */152. public void createPairKey() {153. try {154. // 根据特定的算法一个密钥对生成器155. KeyPairGenerator keygen = KeyPairGenerator.get Instance("DSA");156. // 加密随机数生成器 (RNG)157. SecureRandom random = new SecureRandom(); 158. // 重新设置此随机对象的种子159. random.setSeed(1000);160. // 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器161. keygen.initialize(512, random);// keygen.initi alize(512);162. // 生成密钥组163. KeyPair keys = keygen.generateKeyPair(); 164. // 得到公匙165. PublicKey pubkey = keys.getPublic();166. // 得到私匙167. PrivateKey prikey = keys.getPrivate(); 168. // 将公匙私匙写入到文件当中169. doObjToFile("mykeys.bat", new Object[] { prike y, pubkey });170. } catch (NoSuchAlgorithmException e) {171. e.printStackTrace();172. }173. }174. /**175. * 利用私匙对信息进行签名把签名后的信息放入到指定的文件中176. *177. * @param info178. * 要签名的信息179. * @param signfile180. * 存入的文件181. */182. public void signToInfo(String info, String signfile) {183. // 从文件当中读取私匙184. PrivateKey myprikey = (PrivateKey) getObjFromFile( "mykeys.bat", 1);185. // 从文件中读取公匙186. PublicKey mypubkey = (PublicKey) getObjFromFile("m ykeys.bat", 2);187. try {188. // Signature 对象可用来生成和验证数字签名189. Signature signet = Signature.getInstance("DSA");190. // 初始化签署签名的私钥191. signet.initSign(myprikey);192. // 更新要由字节签名或验证的数据193. signet.update(info.getBytes());194. // 签署或验证所有更新字节的签名，返回签名195. byte[] signed = signet.sign();196. // 将数字签名,公匙,信息放入文件中197. doObjToFile(signfile, new Object[] { signed, m ypubkey, info });198. } catch (Exception e) {199. e.printStackTrace();200. }201. }202. /**203. * 读取数字签名文件根据公匙，签名，信息验证信息的合法性204. *205. * @return true 验证成功 false 验证失败206. */207. public boolean validateSign(String signfile) { 208. // 读取公匙209. PublicKey mypubkey = (PublicKey) getObjFromFile(si gnfile, 2);210. // 读取签名211. byte[] signed = (byte[]) getObjFromFile(signfile,1);212. // 读取信息213. String info = (String) getObjFromFile(signfile, 3) ;214. try {215. // 初始一个Signature对象,并用公钥和签名进行验证216. Signature signetcheck = Signature.getInstance( "DSA");217. // 初始化验证签名的公钥218. signetcheck.initVerify(mypubkey);219. // 使用指定的 byte 数组更新要签名或验证的数据220. signetcheck.update(info.getBytes());221. System.out.println(info);222. // 验证传入的签名223. return signetcheck.verify(signed);224. } catch (Exception e) {225. e.printStackTrace();226. return false;227. }228. }229. /**230. * 将二进制转化为16进制字符串231. *232. * @param b233. * 二进制字节数组234. * @return String235. */236. public String byte2hex(byte[] b) {237. String hs = "";238. String stmp = "";239. for (int n = 0; n < b.length; n++) {240. stmp = (ng.Integer.toHexString(b[n] & 0 XFF));241. if (stmp.length() == 1) {242. hs = hs + "0" + stmp;243. } else {244. hs = hs + stmp;245. }246. }247. return hs.toUpperCase();248. }249. /**250. * 十六进制字符串转化为2进制251. *252. * @param hex253. * @return254. */255. public byte[] hex2byte(String hex) {256. byte[] ret = new byte[8];257. byte[] tmp = hex.getBytes();258. for (int i = 0; i < 8; i++) {259. ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1] );260. }261. return ret;262. }263. /**264. * 将两个ASCII字符合成一个字节；如："EF"--> 0xEF 265. *266. * @param src0267. * byte268. * @param src1269. * byte270. * @return byte271. */272. public static byte uniteBytes(byte src0, byte src1) {273. byte _b0 = Byte.decode("0x" + new String(new byte[ ] { src0 }))274. .byteValue();275. _b0 = (byte) (_b0 << 4);276. byte _b1 = Byte.decode("0x" + new String(new byte[ ] { src1 }))277. .byteValue();278. byte ret = (byte) (_b0 ^ _b1);279. return ret;280. }281. /**282. * 将指定的对象写入指定的文件283. *284. * @param file285. * 指定写入的文件286. * @param objs287. * 要写入的对象288. */289. public void doObjToFile(String file, Object[] objs) {290. ObjectOutputStream oos = null;291. try {292. FileOutputStream fos = new FileOutputStream(fi le);293. oos = new ObjectOutputStream(fos);294. for (int i = 0; i < objs.length; i++) { 295. oos.writeObject(objs[i]);296. }297. } catch (Exception e) {298. e.printStackTrace();299. } finally {300. try {301. oos.close();302. } catch (IOException e) {303. e.printStackTrace();304. }305. }306. }307. /**308. * 返回在文件中指定位置的对象309. *310. * @param file311. * 指定的文件312. * @param i313. * 从1开始314. * @return315. */316. public Object getObjFromFile(String file, int i) { 317. ObjectInputStream ois = null;318. Object obj = null;319. try {320. FileInputStream fis = new FileInputStream(file );321. ois = new ObjectInputStream(fis);322. for (int j = 0; j < i; j++) {323. obj = ois.readObject();324. }325. } catch (Exception e) {326. e.printStackTrace();327. } finally {328. try {329. ois.close();330. } catch (IOException e) {331. e.printStackTrace();332. }333. }334. return obj;335. }336. /**337. * 测试338. *339. * @param args340. */341. public static void main(String[] args) {342. CryptTest jiami = new CryptTest();343. // 执行MD5加密"Hello world!"344. System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));345. // 生成一个DES算法的密匙346. SecretKey key = jiami.createSecretKey("DES"); 347. // 用密匙加密信息"Hello world!"348. String str1 = jiami.encryptToDES(key, "Hello"); 349. System.out.println("使用des加密信息Hello 为:" + str1);350. // 使用这个密匙解密351. String str2 = jiami.decryptByDES(key, str1); 352. System.out.println("解密后为：" + str2);353. // 创建公匙和私匙354. jiami.createPairKey();355. // 对Hello world!使用私匙进行签名356. jiami.signToInfo("Hello", "mysign.bat");357. // 利用公匙对签名进行验证。

数据的加密与解密课程设计

数据的加密与解密课程设计一、课程目标知识目标：1. 学生理解数据加密与解密的基本概念，掌握常见的加密算法及其原理；2. 学生了解加密技术在信息安全中的应用，认识到数据保护的重要性；3. 学生掌握密钥的概念，了解公钥和私钥的作用及区别。

技能目标：1. 学生能运用所学加密算法对简单数据进行加密和解密操作；2. 学生具备分析加密场景，选择合适加密算法的能力；3. 学生能运用加密工具进行数据加密与解密，提高实际操作能力。

情感态度价值观目标：1. 学生培养对信息安全的好奇心和探索欲望，激发学习兴趣；2. 学生认识到保护个人隐私和数据安全的重要性，增强网络安全意识；3. 学生通过学习数据加密与解密，培养解决问题的耐心和毅力。

课程性质：本课程为信息技术学科，旨在让学生了解和掌握数据加密与解密的基本知识，提高信息安全意识。

学生特点：六年级学生具备一定的信息技术基础，对新鲜事物充满好奇，具备一定的自主学习能力。

教学要求：结合学生特点，注重理论与实践相结合，以实际操作为主，培养学生的动手能力和解决问题的能力。

在教学过程中，关注学生的情感态度，引导他们树立正确的价值观。

通过分解课程目标为具体学习成果，为后续教学设计和评估提供依据。

二、教学内容1. 数据加密与解密基本概念：介绍加密、解密、密钥等基本概念，使学生理解加密技术的基本原理。

教材章节：《信息技术》六年级下册第四章第一节。

2. 常见加密算法：讲解对称加密（如AES、DES）、非对称加密（如RSA、ECC）的原理和特点。

教材章节：《信息技术》六年级下册第四章第二节。

3. 加密技术在信息安全中的应用：分析加密技术在通信、存储、支付等场景的应用。

教材章节：《信息技术》六年级下册第四章第三节。

4. 密钥管理：介绍密钥生成、分发、存储和销毁的过程，强调密钥安全的重要性。

教材章节：《信息技术》六年级下册第四章第四节。

5. 实践操作：指导学生使用加密工具进行数据加密与解密，巩固所学知识。

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

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

解密与加密课程设计

解密与加密课程设计一、课程目标知识目标：1. 学生能理解加密与解密的基本概念，掌握常见的加密算法及其原理；2. 学生能描述加密技术在现实生活中的应用，了解信息安全的重要性；3. 学生能运用所学的加密知识，分析并解决简单的加密与解密问题。

技能目标：1. 学生能够运用所学算法，设计简单的加密与解密程序；2. 学生能够通过分析加密算法的优缺点，选择合适的加密方法保护信息安全；3. 学生能够运用逻辑思维和问题解决能力，对加密与解密问题进行探讨和研究。

情感态度价值观目标：1. 学生能够认识到信息安全的重要性，树立保护个人隐私和数据安全的意识；2. 学生能够通过学习加密与解密知识，培养逻辑思维、团队协作和探究精神；3. 学生能够关注我国在信息安全领域的发展，增强国家意识和自豪感。

课程性质：本课程为信息技术课程，旨在帮助学生了解加密与解密知识，提高信息安全意识，培养实际操作能力和逻辑思维能力。

学生特点：六年级学生具有一定的信息技术基础，对新鲜事物充满好奇心，具备一定的逻辑思维能力和动手操作能力。

教学要求：结合学生特点，采用任务驱动、分组合作等教学方法，注重理论与实践相结合，提高学生的信息素养和解决问题的能力。

通过本课程的学习，使学生能够达到上述课程目标，并在实际生活中运用所学知识。

二、教学内容1. 加密与解密基本概念- 定义加密、解密及密钥- 了解加密技术在生活中的应用2. 常见加密算法- 对称加密算法：如DES、AES- 非对称加密算法：如RSA、ECC- 混合加密算法：如SSL/TLS3. 加密算法原理及实现- 分析对称加密和非对称加密的原理- 介绍加密算法在计算机编程中的实现4. 加密与解密技术应用- 数字签名- 网络安全协议：如HTTPS- 移动通信加密5. 信息安全意识- 保护个人隐私和数据安全- 认识到信息安全的重要性6. 实践操作与案例分析- 设计简单的加密与解密程序- 分析加密算法在现实案例中的应用教学内容安排与进度：第一课时：加密与解密基本概念，介绍加密技术在生活中的应用第二课时：对称加密算法及原理，分析DES加密算法第三课时：非对称加密算法及原理，分析RSA加密算法第四课时：混合加密算法，介绍SSL/TLS在网络通信中的应用第五课时：加密与解密技术应用，实践操作与案例分析第六课时：信息安全意识培养，总结课程内容，布置课后作业本教学内容根据课程目标，结合课本知识，注重理论与实践相结合，旨在帮助学生掌握加密与解密知识，提高信息安全意识，为后续学习打下坚实基础。

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中decrypt和encrypt方法

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登录密码加密解密代码

}
return new String(output);
}
}
if(bsh.shared.crypt ==void){
// not yet defined, so create it:
bsh.shared.crypt = new CryptUtil();
}
return hasher.hash().toString();
}
public String sha1(String value) {
Hasher hasher = Hashing.sha1().newHasher();
hasher.putString(value, Charset.forName("UTF-8"));
import mon.hash.Hashing;
public class CryptUtil {
public String md5(String value) {
Hasher hasher = Hashing.md5().newHasher();
hasher.putString(value, Charset.forName("UTF-8"));
cipher.init(Cipher.DECRYPT_MODE, skey);
output = cipher.doFinal(Base64.decodeBase64(input));
} catch (Exception e) {
System.out.println(e.toString());
return hasher.hash().toString();
}
public String base64Encode(String value) {

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

java加密解密desutil、tripledesutil

Java加密解密DESUtil、TripleDESUtil* 注：1、DES使用56位密钥，以现代计算能力，24小时内即可被破解；* 2、3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES 指定为过渡的加密标准）。

使用3条56位的密钥对数据进行三次加密。

* 3、DES算法的加密密钥是根据用户输入的密码生成的,该算法把64位密码中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在计算密钥时要忽略这8位.* 在generateKey()生成的随机密钥为8位（64bit）public static final String ALGORITHM = “DES”;public static final String TRANSFORMA TION = “DES/ECB/PKCS5Padding”;* 生成随机密钥* @return* @throws Exceptionpublic static Key generateKey() throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(new SecureRandom());Key key = keyGenerator.generateKey();return key;* 生成固定密钥* @param seed* @return* @throws Exceptionpublic static Key generateKey(byte[] seed) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(new SecureRandom(seed));Key key = keyGenerator.generateKey();return key;* 生成固定密钥* @param password* @return* @throws Exceptionpublic static Key generateKey(String password) throws Exception {return generateKey(password.getBytes());* 执行加密* @param content* @param key 长度必须为8位，即64bit* @return* @throws Exceptionpublic static byte[] encrypt(byte[] content, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, ALGORITHM)); byte[] output = cipher.doFinal(content);return output;* 执行加密* @param content* @param password* @return* @throws Exceptionpublic static byte[] encrypt(byte[] content, String password) throws Exception { Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.ENCRYPT_MODE, generateKey(password));byte[] output = cipher.doFinal(content);return output;* 执行解密* @param content* @param key 长度必须为8位，即64bit* @return* @throws Exceptionpublic static byte[] decrypt(byte[] content, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, ALGORITHM)); byte[] output = cipher.doFinal(content);return output;* 执行解密* @param content* @param password* @return* @throws Exceptionpublic static byte[] decrypt(byte[] content, String password) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.DECRYPT_MODE, generateKey(password));byte[] output = cipher.doFinal(content);return output;public static void main(String[] args) throws Exception {System.out.println(Arrays.toString(encrypt(“DES使用56位密钥，以现代计算能力”.getBytes(), “012345”)));System.out.println(new String(decrypt(encrypt(“DES使用56位密钥，以现代计算能力”.getBytes(), “012345”), “012345”)));System.out.println(Arrays.toString(encrypt(“DES使用56位密钥，以现代计算能力”.getBytes(), “01234567”.getBytes())));System.out.println(new String(decrypt(encrypt(“DES使用56位密钥，以现代计算能力”.getBytes(), “01234567”.getBytes()), “01234567”.getBytes())));* 控制台输出：* [117, -109, -80, -75, 51, -86, -57, -109, -94, 58, 38, 94, 39, -107, -60, 65, -122, -7, -124, 2, -23, -30, -98, -64, 90, 26, 15, 82, 84, 102, -108, -3, -68, -4, 110, -86, -106, 19, -65, -110, 2, 15, 49, -79, -98, 38, -39, 6]* DES使用56位密钥，以现代计算能力* [-6, 63, -15, 73, -28, 85, 125, 64, 6, 55, -63, 99, 114, 21, 108, -49, 19, 11, -15, -126, 36, -92, 62, 112, -40, 64, -102, 127, -94, -53, -89, 33, 72, -20, -126, -90, 105, -37, -68, -46, -61, -36, 5, -103, 27, 32, 84, 28]* DES使用56位密钥，以现代计算能力[Java]代码import java.security.Key;import java.security.SecureRandom;import java.util.Arrays;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.spec.SecretKeySpec;public sta tic final String ALGORITHM = “DESede”;public static final String TRANSFORMA TION = “DESede/ECB/PKCS5Padding”; * 生成随机密钥* @return* @throws Exceptionpublic static Key generateKey() throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(new SecureRandom());Key key = keyGenerator.generateKey();return key;* 生成固定密钥* @param seed* @return* @throws Exceptionpublic static Key generateKey(byte[] seed) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(new SecureRandom(seed));Key key = keyGenerator.generateKey();return key;* 生成固定密钥* @param password* @return* @throws Exceptionpublic static Key generateKey(String password) throws Exception {return generateKey(password.getBytes());* 执行加密* @param content* @param key 长度必须为8位，即64bit* @return* @throws Exceptionpublic static byte[] encrypt(byte[] content, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, ALGORITHM)); byte[] output = cipher.doFinal(content);return output;* 执行加密* @param content* @param password* @return* @throws Exceptionpublic static byte[] encrypt(byte[] content, String password) throws Exception { Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.ENCRYPT_MODE, generateKey(password));byte[] output = cipher.doFinal(content);return output;* 执行解密* @param content* @param key 长度必须为8位，即64bit* @return* @throws Exceptionpublic static byte[] decrypt(byte[] content, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, ALGORITHM)); byte[] output = cipher.doFinal(content);return output;* 执行解密* @param content* @param password* @return* @throws Exceptionpublic static byte[] decrypt(byte[] content, String password) throws Exception {Cipher cipher = Cipher.getInstance(TRANSFORMA TION);cipher.init(Cipher.DECRYPT_MODE, generateKey(password));byte[] output = cipher.doFinal(content);return output;public static void main(String[] args) throws Exception {System.out.println(Arrays.toString(encrypt(“使用3条56位的密钥对数据进行三次加密。

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

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

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

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

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

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

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

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

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

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

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

Java的MD5盐值加密，Des加密解密和base64加密解密使用方法

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包<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相关加密解密方法

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签名和验证。

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

课程设计(论文)任务书软件学院软件工程专业班一、课程设计(论文)题目加密与解密二、课程设计(论文)工作自年月日起至年月日止。

三、课程设计(论文) 地点:四、课程设计(论文)内容要求：1．本课程设计的目的（1）使学生巩固和提高Java编程技术（2）培养学生掌握程序设计的基本思路和方法；（3）加强学生研发、调试程序的能力；（4）培养学生分析、解决问题的能力；（5）提高学生的科技论文写作能力。

2．课程设计的任务及要求1）任务：（1）设计GUI界面的Hannoi塔，用户可以通过拖动鼠标移动各个塔上的盘子，程序也可以自动演示盘子的移动过程。

；（2）有三个表示塔的对象，分别命名为A、B和C。

A塔上有若干个盘子，盘子的大小不等，并按着大小顺序依次摆放在A塔上，大盘在下，小盘在上。

用户可以用鼠标拖动盘子，把A 塔上的盘子全部移动到另外两个塔中的任何一个塔上。

要求每次只能移动一个盘子，在任何时候不允许大盘压在小盘的上面。

（3）用户也可以选择让程序自动演示。

选择自动演示后，程序将以动画形式演示把A塔上的盘子全部移到C塔的过程，并将移动过程以文本形式显示在一个文本区中。

2）创新要求：在基本要求达到后，可进行创新设计，增加功能和游戏趣味性。

3）课程设计论文编写要求（1）课程设计任务及要求（2）需求分析（3）设计思路--工作原理、功能规划（4）详细设计---数据分析、算法思路、类设计、功能实现（含程序流程图、主要代码及注释）、界面等。

（4）运行调试与分析讨论---给出运行屏幕截图，分析运行结果，有何改进想法等。

（5）设计体会与小结---设计遇到的问题及解决办法，通过设计学到了哪些新知识，巩固了哪些知识，有哪些提高。

（6）参考文献（必须按标准格式列出，可参考教材后面的参考文献格式）(7) 报告按规定排版打印，要求装订平整，否则要求返工；(8) 课设报告的装订顺序如下：封面---任务书---中文摘要---目录----正文---附录(代码及相关图片)（9）严禁抄袭，如有发现，按不及格处理。

4）答辩与评分标准：（1）考勤：10分；（2）程序检查：30分；（3）答辩回答问题：20分（3）课程设计报告：40分；5）参考文献：（1）《Java语言程序设计教程》邱桃荣机械工业出版社（2）《Java程序设计试验指导》陈轶姚晓昆清华大学出版社6）课程设计进度安排内容天数地点构思及收集资料7图书馆编码与调试5实验室撰写论文3图书馆、实验室学生签名：年月日课程设计(论文)评审意见（1）考勤（10分）：优（）、良（）、中（）、一般（）、差（）；（2）程序检查（30分）：优（）、良（）、中（）、一般（）、差（）；（3）答辩回答问题（20分）：优（）、良（）、中（）、一般（）、差（）；（4）设计报告（40分）：优（）、良（）、中（）、一般（）、差（）；评阅人：职称：讲师年月日前言 ......................................................................................................................................... - 3 -一、题目分析................................................................................................................................ - 5 -1.1课程设计的要求和内容（包括原始数据、技术要求、工作要求） (5)1.2相关知识介绍 (5)二、概要设计................................................................................................................................ - 9 -2.1抽象数据类型的定义 (9)2.2主程序流程 (9)2.3各程序模块之间的层次(调用)关系 (10)三、详细设计.............................................................................................................................. - 11 -3.1主函数模块 (11)3.2加密模块 (12)3.3加密操作模块 (13)3.4解密模块 (13)3.5解密操作模块 (15)3.6转换模块 (15)3.7文件选择模块 (16)3.8密码生成模块 (17)四、调试分析.............................................................................................................................. - 19 -4.1调试过程中遇到的问题 (19)4.2对设计与实现的回顾讨论和分析 (19)4.3算法的时空分析 (20)4.4经验和体会 (20)五、测试结果.............................................................................................................................. - 20 -5.1加密 (20)5.2解密 (22)六、主要参考资料 ...................................................................................................................... - 23 -七、附录 ..................................................................................................................................... - 23 -摘要随着网络技术的不断发展，人们的个人信息、网络间的文件传递、电子商务等方面都需要大力的保护，文件加密技术也就随之产生。

文件的加密主要是由加密算法实现，加密算法有多种，常见的有ＲＳＡ、ＤＥＳ、ＭＤ５等。

本程序设计对文件的加密使用的是ＤＥＳ加密算法。

Java语言具有简单、安全、可移植、面向对象、健壮、多线程、体系结构中立、解释执行、高性能、分布式和动态等主要特点。

利用Java语言中秘密密钥工厂对ＤＥＳ算法的支持，使程序实现文件加密、解密两大功能更简单。

关键词：JAVA ； DES；加密；解密；前言DES ( data encryption Standard) 是一种世界标准的加密形式，已经15 年历史了，虽然有些老，可还算是比较可靠的算法。

在七十的初期, 随着计算机之间的通信发展，需要有一种标准密码算法为了限制不同算法的激增使它们之间不能互相对话。

为解决这个问题, 美国国家安全局(N.S.A ) 进行招标。

I.B.M 公司开发了一种算法，称为：Lucifer。

经过几年的研讨和修改, 这种算法, 成为了今天的D.E.S，1976 年11月23 日，终于被美国国家安全局采用。

D.E.S 是分块加密的，将明文分割成 64 BITS 的块, 然后它们一个个接起来。

它使用56位密钥对64位的数据块进行加密，并对64bits的数据块进行16轮编码。

与每轮编码时，一个48bits的“每轮”密钥值由56bits的完整密钥得出来。

DES用软件进行解码需要用很长时间，而用硬件解码速度非常快，1977年，人们估计要耗资两千万美元才能建成一个专门计算机用于DES的解密，而且需要12个小时的破解才能得到结果。

所以，当时DES被认为是一种十分强壮的加密方法。

但今天，只需二十万美圆就可以制造一台破译DES的特殊的计算机，所以现在 DES 对要求“强壮”加密的场合已经不再适用了。

DES的唯一密码学缺点，就是密钥长度相对比较短，人们并没有放弃使用DES，而是想出了一个解决其长度问题的方法，即采用三重DES。

加密成为三步，而不是一步，每一步的密钥都不一样，这样爆破就比较复杂了，这样要找三个密钥，而不是一个，每个密钥有56 BITS，那样我们就有56 乘以三，等于168 Bits。

本程序设计所采用的就是DES的变种——三重DES算法。

同时利用Java的GUI编程，生成文本对话框，对文件的路径进行选择、提供密钥框、加密和解密按钮。

一、题目分析1.1课程设计的要求和内容（包括原始数据、技术要求、工作要求）基本要求：1.利用某种加密算法对指定的文本文件进行加密（应判断其是否已经加密，若已加密则结束该步骤，否则提示输入加密口令，对文件进行加密）；2.加密解密方法：可使用RSA,DES,MD5等之一加密算法。

3．还应该提供解密功能。

1.2相关知识介绍1.2.1 DES算法描述DES是一种分组加密算法，他以64位为分组对数据加密。

64位一组的明文从算法的一端输入，64位的密文从另一端输出。

DES是一个对称算法：加密和解密用的是同一个算法（除密钥编排不同以外）。

密钥的长度为56位(密钥通常表示为64位的数，但每个第8位都用作奇偶检验，可以忽略)。

密钥可以是任意的56位数，且可以在任意的时候改变。

DES算法的入口参数有3个：Key，Data，Mode。

其中Key为8个字节共64位，是DES 算法的工作密钥；Data也为8个字节64位，是要被加密或解密的数据：Mode为DES的工作方式，有两种：加密或解密。

DES算法的工作过程：若Mode为加密，则用Key对数据Data进行加密，生成Data的密码形式（64位）作为DES的输出结果；若Mode为解密，则用Key对密码形式的数据Data 解密，还原为Data的明码形式（64位）作为DES的输出结果。

在通信网络的两端，双方约定了一致的Key，在通信的源点用Key对核心数据进行DES 加密，然后以密码形式通过公共通信网（如电话网）传输到通信网络的终点，数据达到目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。

这样便保证了核心数据（如PIN，MAC等）在公共通信网中传输的安全性和可靠性。

通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性，这正是现在金融界交易网络的流行作法。

简单地说，算法只不过是加密的一种基本技术，DES基本组建分组是这些技术的一种组合，他基于密钥作用于明文，这是众所周知的轮（round）。