java实现Des对TXT文件内容的加解密

合集下载

如何在Java中进行数据的加密和解密

如何在Java中进行数据的加密和解密在Java中，有多种加密和解密的算法可供选择，如对称加密算法、非对称加密算法和哈希算法等。

下面将介绍几种常见的加密和解密方法。

1.对称加密算法对称加密算法指的是使用相同密钥进行加密和解密的算法，常见的对称加密算法有DES、3DES、AES等。

DES加密算法是一种对称密钥算法，加密解密使用相同的密钥，密钥长度为56位。

以下是使用DES加密和解密的示例代码：```javaimport javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class DESExample {public static void main(String[] args) throws Exception { String plainText = "Hello World";String key = "abcdefgh"; //密钥必须是8位长度byte[] encryptedBytes = desEncrypt(plainText.getBytes(), key.getBytes());byte[] decryptedBytes = desDecrypt(encryptedBytes,key.getBytes());String decryptedText = new String(decryptedBytes);System.out.println("解密后的文本：" + decryptedText);}public static byte[] desEncrypt(byte[] plainText, byte[] keyBytes) throws Exception {SecretKey key = new SecretKeySpec(keyBytes, "DES");Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.ENCRYPT_MODE, key);return cipher.doFinal(plainText);}public static byte[] desDecrypt(byte[] cipherText, byte[] keyBytes) throws Exception {SecretKey key = new SecretKeySpec(keyBytes, "DES");Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.DECRYPT_MODE, key);return cipher.doFinal(cipherText);}}```3DES加密算法是DES的一种改进版，使用3个不同的密钥对数据进行3次加密。

实验二 DES加解密算法的实现

实验二 DES加解密算法的实现实验二：DES的编程实现一、实验目的在本实验中，用VC/ C/C++/Java实现DES的加解密算法。

完成实验后将能够深入理解DES加解密算法及其在VC/ C/C++/Java中的实现过程。

二、实验条件熟悉VC/ C/C++/Java开发环境和有关DES算法的有关知识；一台安装有VC/ C/C++/Java的计算机。

三、实验要求本实验要求：输入十六位十六进制明文（占64Bit）和十六位十六进制密钥（占64Bit），输出十六位十六进制密文和六十四位二进制密文。

四、实验步骤对数据进行加密传输能有效地保证数据的机密性，DES是一个保证数据机密性的经典算法，本实验拟在VC/ C/C++/Java环境中实现DES算法。

以下以VC为例：（3）“Win32 Console Application-步骤1共1步”对话框中，选择“一个空工程”单选按钮，单击“完成”按钮，再单击“确定”按钮。

图2 “Win32 Console Application-步骤1共1步”对话框（4）在VC环境中，在其左侧的工程工作区窗口下端中选择标签“FileView”，单击“DES files”前面的“+”号展开。

图3 标签“FileView”（5）鼠标右击“Source Files”，选择“添加文件到目录”，将testMain.cpp和zlDES.cpp添加进“Source Files”。

同样，鼠标右击“Header Files”，选择“添加文件到目录”，将zlDES.h 添加进“Header Files”。

结果，如图4。

图4 标签“FileView”（6）选择“组建|编译”，分别编译testMain.cpp和zlDES.cpp。

然后再选择“组建|执行”，即可看到结果。

五、编写源代码（1）DES算法详述（主要描述算法流程）DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下：其中每一轮轮结构为：（2）可以参照如下VC++代码。

Java中的数据加密与解密

Java中的数据加密与解密数据加密与解密在现代信息安全中起着至关重要的作用。

Java作为一种广泛应用的编程语言，提供了丰富的工具和库来实现数据的加密和解密。

本文将介绍Java中常用的数据加密与解密的方法，包括对称加密和非对称加密。

一、对称加密对称加密是指使用相同的密钥进行数据的加密和解密。

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

下面分别介绍这两种算法的使用方法。

1. DES加密与解密DES（Data Encryption Standard）是一种对称加密算法，使用相同的密钥进行加密和解密。

在Java中，可以使用javax.crypto包下的Cipher 类来实现DES加密和解密的功能。

具体代码如下：```javaimport javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;public class DESUtils {private static final String ALGORITHM = "DES";public static String encrypt(String data, String key) throws Exception {SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, keySpec);byte[] encryptedData = cipher.doFinal(data.getBytes());return new String(encryptedData);}public static String decrypt(String encryptedData, String key) throws Exception {SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, keySpec);byte[] decryptedData = cipher.doFinal(encryptedData.getBytes());return new String(decryptedData);}}```2. AES加密与解密AES（Advanced Encryption Standard）是一种高级的对称加密算法，相较于DES更为安全、高效。

DES加密和解密java代码

DES加密和解密java代码在说DES加密算法之前，我们⾸先了解⼏个基本概念：1. 明⽂：明⽂是指没有经过加密的数据。

⼀般⽽⾔，明⽂都是等待传输的数据。

由于没有经过加密，明⽂很容易被识别与破解，因此在传输明⽂之前必须进⾏加密处理。

2. 密⽂：密⽂只是明⽂经过某种加密算法⽽得到的数据，通常密⽂的形式复杂难以识别及理解。

3. 密钥：密钥是⼀种参数，它是在明⽂转换为密⽂或将密⽂转换为明⽂的算法中输⼊的参数。

4. 对称加密：通信双⽅同时掌握⼀个密钥，加密解密都是由⼀个密钥完成的（即加密密钥等于解密密钥，加解密密钥可以相互推倒出来）。

双⽅通信前共同拟定⼀个密钥，不对第三⽅公开。

5. 分组加密：分组密码是将明⽂分成固定长度的组，每⼀组都采⽤同⼀密钥和算法进⾏加密，输出也是固定长度的密⽂。

好了了解这些以后，我们再来说DES加密算法。

DES 算法是⼀种常见的分组加密算法，由IBM公司在1971年提出。

DES 算法是分组加密算法的典型代表，同时也是应⽤最为⼴泛的对称加密算法。

下⾯我们详细介绍下：1.分组长度：DES 加密算法中，明⽂和密⽂为 64 位分组。

密钥的长度为 64 位，但是密钥的每个第⼋位设置为奇偶校验位，因此密钥的实际长度为56位。

2.加密流程：DES 加密算法⼤致分为 4 步：初始置换、⽣成⼦密钥、迭代过程、逆置换。

代码如下：需特别注意：不要使⽤JDK中⾃带的sun.misc.BASE64Decoder类去做BASE64，该类会在最后⾯多加换⾏。

⽽应使⽤apache中的mons.codec.binary.Base64这个类来做base64加密。

（待验证）import javax.crypto.Cipher;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvParameterSpec;import java.security.Key;import java.security.SecureRandom;import mons.codec.binary.Base64;public class DESUtil {// 偏移变量，固定占8位字节private final static String IV_PARAMETER = "12345678";// 字符编码public static final String CHARSET_UTF8 = "UTF-8";// 加密算法DESpublic static final String DES = "DES";// 电话本模式public static final String DES_ECB = "DES/ECB/PKCS5Padding";// 加密块链模式--推荐public static final String DES_CBC = "DES/CBC/PKCS5Padding";// 测试public static void main(String args[]) {// 待加密内容String str = "false";// 密码，长度要是8的倍数String password = "87654321";String result = DESUtil.encryptCBC(password, str);System.out.println("加密后：" + new String(result));// 直接将如上内容解密try {String decryResult = DESUtil.decryptCBC(password, result);System.out.println("解密后：" + new String(decryResult));} catch (Exception e1) {e1.printStackTrace();}}/*** ⽣成key** @param password* @return* @throws Exception*/private static Key generateKey(String password) throws Exception {DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET_UTF8));SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);return keyFactory.generateSecret(dks);}/*** DES加密字符串--ECB格式** @param password* 加密密码，长度不能够⼩于8位* @param data* 待加密字符串* @return加密后内容*/public static String encryptECB(String password, String data) {if (password == null || password.length() < 8) {throw new RuntimeException("加密失败，key不能⼩于8位");}if (data == null) {return null;}try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_ECB);cipher.init(Cipher.ENCRYPT_MODE, secretKey, new SecureRandom());byte[] bytes = cipher.doFinal(data.getBytes(CHARSET_UTF8));// JDK1.8及以上可直接使⽤Base64，JDK1.7及以下可以使⽤BASE64Encoder return new String(Base64.encodeBase64(bytes));} catch (Exception e) {e.printStackTrace();return data;}}/*** DES解密字符串--ECB格式** @param password* 解密密码，长度不能够⼩于8位* @param data* 待解密字符串* @return解密后内容*/public static String decryptECB(String password, String data)throws Exception {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_ECB);cipher.init(Cipher.DECRYPT_MODE, secretKey, new SecureRandom());return new String(cipher.doFinal(Base64.decodeBase64(data.getBytes(CHARSET_UTF8))), CHARSET_UTF8);}/*** DES加密字符串-CBC加密格式** @param password* 加密密码，长度不能够⼩于8位* @param data* 待加密字符串* @return加密后内容*/public static String encryptCBC(String password, String data) {if (password == null || password.length() < 8) {throw new RuntimeException("加密失败，key不能⼩于8位");}if (data == null) {return null;}try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_CBC);IvParameterSpec spec = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET_UTF8));cipher.init(Cipher.ENCRYPT_MODE, secretKey, spec);byte[] bytes = cipher.doFinal(data.getBytes(CHARSET_UTF8));// JDK1.8及以上可直接使⽤Base64，JDK1.7及以下可以使⽤BASE64Encoder return new String(Base64.encodeBase64(bytes));} catch (Exception e) {e.printStackTrace();return data;}}/*** DES解密字符串--CBC格式** @param password* 解密密码，长度不能够⼩于8位* @param data* 待解密字符串* @return解密后内容*/public static String decryptCBC(String password, String data) throws Exception {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_CBC);IvParameterSpec spec = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET_UTF8));cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);return new String(cipher.doFinal(Base64.decodeBase64(data.getBytes(CHARSET_UTF8))), CHARSET_UTF8); }}。

java实现文件内容的加密和解密

java实现⽂件内容的加密和解密package com.umapp.test;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;import java.security.Key;import java.security.SecureRandom;import javax.crypto.Cipher;import javax.crypto.CipherInputStream;import javax.crypto.CipherOutputStream;import javax.crypto.KeyGenerator;public class TestDES {Key key;public TestDES(String str) {getKey(str);//⽣成密匙}/*** 根据参数⽣成KEY*/public void getKey(String strKey) {try {KeyGenerator _generator = KeyGenerator.getInstance("DES");_generator.init(new SecureRandom(strKey.getBytes()));this.key = _generator.generateKey();_generator = null;} catch (Exception e) {throw new RuntimeException("Error initializing SqlMap class. Cause: " + e);}}/*** ⽂件file进⾏加密并保存⽬标⽂件destFile中** @param file 要加密的⽂件如c:/test/srcFile.txt* @param destFile 加密后存放的⽂件名如c:/加密后⽂件.txt*/public void encrypt(String file, String destFile) throws Exception {Cipher cipher = Cipher.getInstance("DES");// cipher.init(Cipher.ENCRYPT_MODE, getKey());cipher.init(Cipher.ENCRYPT_MODE, this.key);InputStream is = new FileInputStream(file);OutputStream out = new FileOutputStream(destFile);CipherInputStream cis = new CipherInputStream(is, cipher);byte[] buffer = new byte[1024];int r;while ((r = cis.read(buffer)) > 0) {out.write(buffer, 0, r);}cis.close();is.close();out.close();}/*** ⽂件采⽤DES算法解密⽂件** @param file 已加密的⽂件如c:/加密后⽂件.txt* * @param destFile* 解密后存放的⽂件名如c:/ test/解密后⽂件.txt*/public void decrypt(String file, String dest) throws Exception {Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.DECRYPT_MODE, this.key);InputStream is = new FileInputStream(file);OutputStream out = new FileOutputStream(dest);CipherOutputStream cos = new CipherOutputStream(out, cipher);byte[] buffer = new byte[1024];int r;while ((r = is.read(buffer)) >= 0) {System.out.println();cos.write(buffer, 0, r);}cos.close();out.close();is.close();}public static void main(String[] args) throws Exception {TestDES td = new TestDES("aaa");td.encrypt("e:/r.txt", "e:/r解密.txt"); //加密 td.decrypt("e:/r解密.txt", "e:/r1.txt"); //解密 }}。

DES加密解密Java代码

mainMenu.add(generateItem);
mainMenu.addSeparator();
mainMenu.add(encryptItem);
mainMenu.add(decryptItem);
menuBar.add(mainMenu);
setJMenuBar(menuBar);
//添加文本区
if (fileName == null)
return;
//读取密文
FileInputStream fis = new FileInputStream(fileName);
byte[] cipherText = new byte[fis.available()];
fis.read(cipherText);
jfc.setDialogTitle("打开加密文本内容");
if (jfc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
fileName = jfc.getSelectedFile().getPath();
}
//如果没有选择文件，就退出
e1.printStackTrace();
}
} else if (e.getSource() == decryptItem) {
try {
//读取密钥文件的完整路径
String fileName = null;
//设置文件选择对话框
JFileChooser jfc = new JFileChooser();
add(jsp);
//添加事件监听
generateItem.addActionListener(this);

DES 加解密算法(java和c#版)

/** java 版的* Title: DES 加解密算法* Description: DES 加解密算法* Copyright: Copyright (c) 2004* Company: Aspire Corp* @author zhangji* @version 1.0*/import java.security.*;import javax.crypto.*;public class DES {private static String strDefaultKey = "hnzt";private Cipher encryptCipher = null;private Cipher decryptCipher = null;/*** 将byte数组转换为表示16进制值的字符串，* 如：byte[]{8,18}转换为：0813，* 和public static byte[] hexStr2ByteArr(String strIn)* 互为可逆的转换过程* @param arrB 需要转换的byte数组* @return 转换后的字符串* @throws Exception 本方法不处理任何异常，所有异常全部抛出*/public static String byteArr2HexStr(byte[] arrB)throws Exception{int iLen = arrB.length;//每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍StringBuffer sb = new StringBuffer(iLen * 2);for (int i = 0; i < iLen; i++){int intTmp = arrB[i];//把负数转换为正数while (intTmp < 0){intTmp = intTmp + 256;}//小于0F的数需要在前面补0if (intTmp < 16){sb.append("0");}sb.append(Integer.toString(intTmp, 16));}return sb.toString();}/*** 将表示16进制值的字符串转换为byte数组，* 和public static String byteArr2HexStr(byte[] arrB)* 互为可逆的转换过程* @param strIn 需要转换的字符串* @return 转换后的byte数组* @throws Exception 本方法不处理任何异常，所有异常全部抛出* @author <a href="mailto:zhangji@">ZhangJi</a> */public static byte[] hexStr2ByteArr(String strIn)throws Exception{byte[] arrB = strIn.getBytes();int iLen = arrB.length;//两个字符表示一个字节，所以字节数组长度是字符串长度除以2byte[] arrOut = new byte[iLen / 2];for (int i = 0; i < iLen; i = i + 2){String strTmp = new String(arrB, i, 2);arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);}return arrOut;}/*** 默认构造方法，使用默认密钥* @throws Exception*/public DES()throws Exception{this(strDefaultKey);}/*** 指定密钥构造方法* @param strKey 指定的密钥* @throws Exception*/public DES(String strKey)throws Exception{Security.addProvider(new com.sun.crypto.provider.SunJCE()); Key key = getKey(strKey.getBytes());encryptCipher = Cipher.getInstance("DES");encryptCipher.init(Cipher.ENCRYPT_MODE, key);decryptCipher = Cipher.getInstance("DES");decryptCipher.init(Cipher.DECRYPT_MODE, key);}/*** 加密字节数组* @param arrB 需加密的字节数组* @return 加密后的字节数组* @throws Exception*/public byte[] encrypt(byte[] arrB)throws Exception{return encryptCipher.doFinal(arrB);}/*** 加密字符串* @param strIn 需加密的字符串* @return 加密后的字符串* @throws Exception*/public String encrypt(String strIn)throws Exception{return byteArr2HexStr(encrypt(strIn.getBytes())); }/*** 解密字节数组* @param arrB 需解密的字节数组* @return 解密后的字节数组* @throws Exception*/public byte[] decrypt(byte[] arrB)throws Exception{return decryptCipher.doFinal(arrB);}/*** 解密字符串* @param strIn 需解密的字符串* @return 解密后的字符串* @throws Exception*/public String decrypt(String strIn)throws Exception{return new String(decrypt(hexStr2ByteArr(strIn)));}/*** 从指定字符串生成密钥，密钥所需的字节数组长度为8位* 不足8位时后面补0，超出8位只取前8位* @param arrBTmp 构成该字符串的字节数组* @return 生成的密钥* @throws ng.Exception*/private Key getKey(byte[] arrBTmp)throws Exception{//创建一个空的8位字节数组（默认值为0）byte[] arrB = new byte[8];//将原始字节数组转换为8位for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {arrB[i] = arrBTmp[i];}//生成密钥Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES"); return key;}/*** 单元测试方法* @param args*/public static void main(String[] args){String strOriginal = "1111";String strOp = "-de";// 检查入参个数if (args.length == 2 ){strOp = args[0] ;strOriginal = args[1];}else{System.out.println("Wrong Parameter count , try use \"java DES -de|-en 'the string you want to be Encrypted'\"");System.out.println("Now do Encrypt with \"1111\"");try{DES des = new DES();// 加密测试System.out.println("***** 加密测试 *****") ;des.enTest("1111");// 解密测试System.out.println("***** 解密测试 *****") ;des.deTest("0fc7648b53e54cfb");}catch (Exception ex){ex.printStackTrace();}return ;}try{if ( strOp.equals("-de")) {DES des = new DES();des.deTest(strOriginal);}else if ( strOp.equals("-en")) {DES des = new DES();des.enTest(strOriginal);}else{System.out.println("Wrong operater , try use \"java DES -de|-en 'the string you want to be Encrypted'\"");System.out.println("Now do Encrypt with \"1111\""); }}catch (Exception ex){ex.printStackTrace();}}/*** 单元测试方法，打印对指定字符串加密后的字符串*/private void enTest(String strOriginal){try{System.out.println("Plain String: " + strOriginal);String strEncrypt= encrypt(strOriginal);System.out.println("Encrypted String: " + strEncrypt);}catch (Exception ex){ex.printStackTrace();}}/*** 单元测试方法，打印对指定字符串解密后的字符串*/private void deTest(String strOriginal){try{System.out.println("Encrypted String: " + strOriginal); System.out.println("Encrypted String length = " + strOriginal.length());String strPlain = decrypt(strOriginal);System.out.println("Plain String: " + strPlain);}catch (Exception ex){ex.printStackTrace();}}}===============c#版的================using System;using System.Text;using System.IO;using System.Security.Cryptography;class Class1{static void Main(){Console.WriteLine("Encrypt String...");txtKey = "tkGGRmBErvc=";btnKeyGen();Console.WriteLine("Encrypt Key :{0}",txtKey);txtIV = "Kl7ZgtM1dvQ=";btnIVGen();Console.WriteLine("Encrypt IV :{0}",txtIV);Console.WriteLine();string txtEncrypted = EncryptString("1111");Console.WriteLine("Encrypt String : {0}",txtEncrypted);string txtOriginal = DecryptString(txtEncrypted);Console.WriteLine("Decrypt String : {0}",txtOriginal);}private static SymmetricAlgorithm mCSP;private static string txtKey;private static string txtIV;private static void btnKeyGen(){mCSP = SetEnc();byte[] byt2 = Convert.FromBase64String(txtKey);mCSP.Key = byt2;}private static void btnIVGen(){byte[] byt2 = Convert.FromBase64String(txtIV);mCSP.IV = byt2;}private static string EncryptString(string Value){ICryptoTransform ct;MemoryStream ms;CryptoStream cs;byte[] byt;ct = mCSP.CreateEncryptor(mCSP.Key, mCSP.IV);byt = Encoding.UTF8.GetBytes(Value);ms = new MemoryStream();cs = new CryptoStream(ms, ct, CryptoStreamMode.Write); cs.Write(byt, 0, byt.Length);cs.FlushFinalBlock();cs.Close();return Convert.ToBase64String(ms.ToArray());}private static string DecryptString(string Value){ICryptoTransform ct;MemoryStream ms;CryptoStream cs;byte[] byt;ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);byt = Convert.FromBase64String(Value);ms = new MemoryStream();cs = new CryptoStream(ms, ct, CryptoStreamMode.Write); cs.Write(byt, 0, byt.Length);cs.FlushFinalBlock();cs.Close();return Encoding.UTF8.GetString(ms.ToArray());}private static SymmetricAlgorithm SetEnc() {return new DESCryptoServiceProvider(); }}。

JAVA加密解密DES对称加密算法

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

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

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

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

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

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

JAVA使用DES加密算法加密解密

JAVA使⽤DES加密算法加密解密程序中使⽤了.properties⽂件作为参数配置⽂档，好处是灵活配置各项参数⼀旦对数据库的⼀些参数进⾏了配置，势必涉及数据库的IP，端⼝，⽤户名和密码properties⽂件全是unicode编码明⽂存储，程序打包交付后，其他⼈能够很容易使⽤解压软件打开jar查看你的.properties⽂件所以⼀些敏感变量需要加密处理⾸先需要了解⼀些基本的加密算法，⽐如MD5，⽐如DES和RSAMD5是⼀种不可逆的加密算法，使⽤散列后特征码的⽅式表现需要加密的字符或者⽂件，常⽤在系统登陆的密码⽐对中将MD5码存储在数据库中，⽤户登陆时将⽤户输⼊的字符散列成MD5后于数据库中的密⽂进⾏⽐对不可逆的加密算法有⼀种好处就是，即使后台数据库被攻破了，对⽅拿这些MD5散列密⽂也毫⽆办法求得明⽂DES和RSA都是可逆的加密算法，也就是可以通过密钥和密⽂解开得到明⽂，其中最常见的64位轮转DES算法在JAVA的JDK中提供了先天性的良好的加密⽀持，其中就包括⼤名⿍⿍的DES下⾯⼀个DESHelper类展⽰了如何将密⽂解开得到明⽂的⽅法package com.newflypig.des;import java.security.SecureRandom;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import sun.misc.BASE64Decoder;/*** 处理数据库密码的密⽂转明⽂类* @author newflypig* time：2015年10⽉30⽇* TODO**/public class DESHelper {/*** Description 根据键值进⾏解密* @param data* @param key 加密键byte数组* @return* @throws Exception*/private static byte[] decrypt(byte[] data, byte[] key) throws Exception {// ⽣成⼀个可信任的随机数源SecureRandom sr = new SecureRandom();// 从原始密钥数据创建DESKeySpec对象DESKeySpec dks = new DESKeySpec(key);// 创建⼀个密钥⼯⼚，然后⽤它把DESKeySpec转换成SecretKey对象SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");SecretKey securekey = keyFactory.generateSecret(dks);// Cipher对象实际完成解密操作Cipher cipher = Cipher.getInstance("DES");// ⽤密钥初始化Cipher对象cipher.init(Cipher.DECRYPT_MODE, securekey, sr);return cipher.doFinal(data);}public static String decrypt(String data, String key) throws Exception {if (data == null)return null;BASE64Decoder decoder = new BASE64Decoder();byte[] buf = decoder.decodeBuffer(data);byte[] bt = decrypt(buf, key.getBytes());return new String(bt);}}如需对加密算法有更深刻的了解，可以⾃⾏研究实现原理，对于敏捷开发这⾥只需要不求甚解的运⽤就⾏了，记得保护好你的key也就是密钥⼀开始提到的需要将properties⽂件中的参数解开得到明⽂，想必你应该已经知道该使⽤哪种加密算法了吧对了，就是上⾯的DES加密算法，这⾥只提供了解密，因为不需要在程序中提供加密函数各位可以⾃⼰编写⾃⼰的加密函数，或者可以在⾃⼰的JUnit测试⾥⾯写加密的语句⽤来对数据库密码进⾏加密。

Java实现DES加解密算法解析

Java实现DES加解密算法解析本⽂实例讲述了Java实现DES加解密算法解析。

分享给⼤家供⼤家参考，具体如下：简介：数据加密算法（Data Encryption Algorithm，DEA）是⼀种对称加密算法，很可能是使⽤最⼴泛的密钥系统，特别是在保护⾦融数据的安全中，最初开发的DEA是嵌⼊硬件中的。

通常，⾃动取款机（Automated Teller Machine，ATM）都使⽤DEA。

它出⾃IBM的研究⼯作，IBM也曾对它拥有⼏年的专利权，但是在1983年已到期后，处于公有范围中，允许在特定条件下可以免除专利使⽤费⽽使⽤。

1977年被美国政府正式采纳。

1998年后实⽤化DES破译机的出现彻底宣告DES算法已不具备安全性，1999年NIST颁布新标准，规定DES算法只能⽤于遗留加密系统，但不限制使⽤DESede算法。

当今DES算法正是推出历史舞台，AES算法称为他的替代者。

加密原理：DES 使⽤⼀个 56 位的密钥以及附加的 8 位奇偶校验位，产⽣最⼤ 64 位的分组⼤⼩。

这是⼀个迭代的分组密码，使⽤称为Feistel 的技术，其中将加密的⽂本块分成两半。

使⽤⼦密钥对其中⼀半应⽤循环功能，然后将输出与另⼀半进⾏“异或”运算；接着交换这两半，这⼀过程会继续下去，但最后⼀个循环不交换。

DES 使⽤ 16 个循环，使⽤异或，置换，代换，移位操作四种基本运算。

JDK对DES算法的⽀持密钥长度：56位⼯作模式：ECB/CBC/PCBC/CTR/CTS/CFB/CFB8 to CFB128/OFB/OBF8 to OFB128填充⽅式：Nopadding/PKCS5Padding/ISO10126Padding/Java 加密解密之对称加密算法DESedeDESede 即三重DES加密算法，也被称为3DES或者Triple DES。

使⽤三(或两)个不同的密钥对数据块进⾏三次(或两次)DES 加密(加密⼀次要⽐进⾏普通加密的三次要快)。

DES加解密的JAVA实现

一、实验目的用java编程实现DES加解密算法，以便深入理解DES加解密算法原理。

二、实验条件1、熟悉JA V A开发环境，能熟练运用JA V A进行程序编写；2、掌握DES加解密算法知识，了解其算法原理；3、安装了JA V A环境的计算机。

三、实验原理1、DES加解密过程：1）、初始置换：对于给定的明文分组x，通过初始置换表IP对x进行置换，得到一个64位的输出串x0，即将输入的第58位换到第一位，第50位换到第2位，...，依此类推，最后一位是原来的第7位。

对于所得到64位的输出串x0，记x0 = IP(x) = L0 R0，其中L0为x0的前32位，R0为x0的后32位。

2）、迭代变换：按照规则迭代。

规则为：Li=Ri-1Ri=Li⊕f(Ri-1, Ki) (i=1,2,3, (16)经过第1步变换已经得到L0和R0的值，其中符号⊕表示数学运算“异或”，f表示一种置换，由s盒置换构成，Ki是一些由密钥编排函数产生的比特块。

迭代变换利用16轮循环，每轮循环使用子密钥对Li 和Ri进行分别处理，对输出结果进行异或运算和交换操作，以实现数据和密钥的结合。

3）、逆置换：类似的，经过16轮迭代后所得到的串R16 、L16应用初始置换的逆置换IP-1，获得密文y，即y = IP-1(R16 , L16)。

2、密码函数f函数f的输入是一个32比特串（当前状态的右半部）和子密钥。

密钥编排方案(k1,k2,…,k32)由16个48比特的子密钥组成，这些子密钥由56比特的种子密钥k 导出。

每个ki 都是由置换选择而来，子密钥的产生过程后面详述。

它主要包含了一个应用S 盒的替代以及其后跟随的一个固定置换P 。

密码函数f 是整个加密的关键部分，它包含了如下四个功能：扩展函数E 、S 盒运算、模2加法、置换函数。

其中，E 位选择表如下：Ki 是由密钥产生的48位比特串，具体的算法是：将E 的选位结果与 ki 作异或操作，得到一个48位输出。

javades加密解密工具类

Java DES加密解密工具类import javax.crypto.IllegalBlockSizeException;import javax.crypto.NoSuchPaddingException;import javax.crypto.spec.SecretKeySpec;import mons.codec.binary.Base64;public class DES {public DES() {public static DES getInstance(String key) throws NoSuchPaddingException, NoSuchAlgorithmException {return getInstance(getKeyByStr(key));public static DES getInstance(byte key[]) throws NoSuchPaddingException, NoSuchAlgorithmException {DES des = new DES();if (des.key == null) {SecretKeySpec spec = new SecretKeySpec(key, DESdes.key = spec;des.cipher = Cipher.getInstance( DES/ECB/PKCS5Paddingreturn des;public byte[] encrypt(byte b[]) throws InvalidKeyException,BadPaddingException, IllegalBlockSizeException,IllegalStateException {byte byteFina[] = null;cipher.init(1, key);byteFina = cipher.doFinal(b);return byteFina;public byte[] decrypt(byte b[]) throws InvalidKeyException, BadPaddingException, IllegalBlockSizeException,IllegalStateException {byte byteFina[] = null;cipher.init(2, key);byteFina = cipher.doFinal(b);return byteFina;public static byte[] getKeyByStr(String str) {byte bRet[] = new byte[str.length() / 2];for (int i = 0; i str.length() / 2; i++) {Integer itg = new Integer(16 * getChrInt(str.charAt(2 * i)) + getChrInt(str.charAt(2 * i + 1)));bRet[i] = itg.byteV alue();return bRet;private static int getChrInt(char chr) {int iRet = 0;if (chr == 0 .charAt(0))iRet = 0;if (chr == 1 .charAt(0))iRet = 1;if (chr == 2 .charAt(0)) iRet = 2;if (chr == 3 .charAt(0)) iRet = 3;if (chr == 4 .charAt(0)) iRet = 4;if (chr == 5 .charAt(0)) iRet = 5;if (chr == 6 .charAt(0)) iRet = 6;if (chr == 7 .charAt(0)) iRet = 7;if (chr == 8 .charAt(0)) iRet = 8;if (chr == 9 .charAt(0)) iRet = 9;if (chr == A .charAt(0)) iRet = 10;if (chr == B .charAt(0)) iRet = 11;if (chr == C .charAt(0)) iRet = 12;if (chr == D .charAt(0))iRet = 13;if (chr == E .charAt(0))iRet = 14;if (chr == F .charAt(0))iRet = 15;return iRet;private Key key;private Cipher cipher;/*** @interpret 进行base64加密操作* @param text* @param keyString* @return Stringpublic String encrypt(String text, String keyString) { String body = null;try {DES des = DES.getInstance(keyString);byte[] b = des.encrypt(text.getBytes( UTF8 ));body = new String(Base64.encodeBase64(b));} catch (Exception ex) {return body;/*** @interpret 进行base64进行解密* @param text* @param keyString* @return Stringpublic String decrypt(String text, String keyString) {String body = null;try {DES des = DES.getInstance(keyString);byte[] b = Base64.decodeBase64(text.getBytes());body = new String(des.decrypt(b), UTF8} catch (Exception e) {e.printStackTrace();return body;public String authcode(String content, String operation, String key){ String encontent = null;if (operation != null operation.equals( DECODE )) {encontent = encrypt(content,key);} else if (operation != null operation.equals( ENCODE )) {encontent = decrypt(content,key);return encontent;public static void main(String[] args) {DES des = new DES();System.out.println(des.authcode( wewweewewew= , DECODE , 0102030405060708 ));//加密System.out.println(des.authcode( d8fPhfd9JkW99p8aqhtVIA== , ENCODE , 0102030405060708 ));//解密}。

JAVA使用DES加密解密

JAVA使⽤DES加密解密在使⽤DES加密解密的时候，遇到了⼀些问题，廖记⼀下。

如有哪位⼤神亲临留⾔指点，不胜感激。

先上代码：public DESUtil() {}//密码，长度要是8的倍数注意此处为简单密码简单应⽤要求不⾼时可⽤此密码 /*DES是⼀种对称加密算法，所谓对称加密算法即：加密和解密使⽤相同密钥的算法。

DES加密算法出⾃IBM的研究，后来被美国政府正式采⽤，之后开始⼴泛流传，但是近些年使⽤越来越少，因为DES使⽤56位密钥，以现代计算能⼒，24⼩时内即可被破解。

*/private static String password = "9588888888880288";//测试public static void main(String args[]) {//待加密内容String str = "task_id=TSK_000000006870&ledger_id=0715-5572";String result = DESUtil.encrypt(str);BASE64Encoder base64en = new BASE64Encoder();// String strs = new String(base64en.encode(result));System.out.println("加密后："+result);//直接将如上内容解密try {String decryResult = DESUtil.decryptor(result);System.out.println("解密后："+new String(decryResult));} catch (Exception e1) {e1.printStackTrace();}}/**** @Method: encrypt* @Description: 加密数据* @param data* @return* @throws Exception* @date 2016年7⽉26⽇*/public static String encrypt(String data) { //对string进⾏BASE64Encoder转换byte[] bt = encryptByKey(data.getBytes(), password);BASE64Encoder base64en = new BASE64Encoder();String strs = new String(base64en.encode(bt));return strs;}/**** @Method: encrypt* @Description: 解密数据* @param data* @return* @throws Exception* @date 2016年7⽉26⽇*/public static String decryptor(String data) throws Exception { //对string进⾏BASE64Encoder转换sun.misc.BASE64Decoder base64en = new sun.misc.BASE64Decoder();byte[] bt = decrypt(base64en.decodeBuffer(data), password);String strs = new String(bt);return strs;}/*** 加密* @param datasource byte[]* @param password String* @return byte[]*/private static byte[] encryptByKey(byte[] datasource, String key) {try{SecureRandom random = new SecureRandom();DESKeySpec desKey = new DESKeySpec(key.getBytes());//创建⼀个密匙⼯⼚，然后⽤它把DESKeySpec转换成SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");SecretKey securekey = keyFactory.generateSecret(desKey);//Cipher对象实际完成加密操作Cipher cipher = Cipher.getInstance("DES");//⽤密匙初始化Cipher对象cipher.init(Cipher.ENCRYPT_MODE, securekey, random);//现在，获取数据并加密//正式执⾏加密操作return cipher.doFinal(datasource);}catch(Throwable e){e.printStackTrace();}return null;}/*** 解密* @param src byte[]* @param password String* @return byte[]* @throws Exception*/private static byte[] decrypt(byte[] src, String key) throws Exception {// DES算法要求有⼀个可信任的随机数源SecureRandom random = new SecureRandom();// 创建⼀个DESKeySpec对象DESKeySpec desKey = new DESKeySpec(key.getBytes());// 创建⼀个密匙⼯⼚SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 将DESKeySpec对象转换成SecretKey对象SecretKey securekey = keyFactory.generateSecret(desKey);// Cipher对象实际完成解密操作Cipher cipher = Cipher.getInstance("DES");// ⽤密匙初始化Cipher对象cipher.init(Cipher.DECRYPT_MODE, securekey, random);// 真正开始解密操作return cipher.doFinal(src);}解密过程中总有各种异常，有的说 SecureRandom 有问题需要换个⽅式⽣产随机数。

基于DES算法的数据文件加密解密的java编程实现

基于DES算法的数据文件加密/解密的java编程实现1 课题背景和意义据记载，公元前400年，古希腊人发明了置换密码。

1881年世界上的第一个电话保密专利出现。

在第二次世界大战期间，德国军方启用“恩尼格玛”密码机，密码学在战争中起着非常重要的作用。

随着信息化和数字化社会的发展，人们对信息安全和保密的重要性认识不断提高，于是在1997年，美国国家标准局公布实施了“美国数据加密标准（DES）”，民间力量开始全面介入密码学的研究和应用中，采用的加密算法有DES、RSA、SHA等。

随着对加密强度需求的不断提高，近期又出现了AES、ECC等。

我国也相应提出了自己国家的ECC、SCB2、SCH 等加密算法。

使用密码学可以达到以下目的：1.保密性：防止用户的标识或数据被读取。

2.数据完整性：防止数据被更改。

3.身份验证：确保数据发自特定的一方。

随着计算机和通信网络的广泛应用，信息的安全性已经受到人们的普遍重视。

信息安全已不仅仅局限于政治，军事以及外交领域，而且现在也与人们的日常生活息息相关。

现在，密码学理论和技术已得到了迅速的发展，它是信息科学和技术中的一个重要研究领域。

在近代密码学上值得一提的大事有两件：一是1977年美国国家标准局正式公布实施了美国的数据加密标准（DES），公开它的加密算法，并批准用于非机密单位及商业上的保密通信。

密码学的神秘面纱从此被揭开。

二是Diffie和Hellman联合写的一篇文章“密码学的新方向”，提出了适应网络上保密通信的公钥密码思想，拉开了公钥密码研究的序幕。

DES（Data Encryption Standard）是IBM公司于上世纪1977年提出的一种数据加密算法。

在过去近三十年的应用中，还无法将这种加密算法完全、彻底地破解掉。

而且这种算法的加解密过程非常快，至今仍被广泛应用，被公认为安全的。

虽然近年来由于硬件技术的飞速发展，破解DES已经不是一件难事，但学者们似乎不甘心让这样一个优秀的加密算法从此废弃不用，于是在DES的基础上有开发了双重DES（DoubleDES,DDES）和三重DES（Triple DES,TDES）。

java实现DES加密解密算法

java实现DES加密解密算法DES算法的⼊⼝参数有三个：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，便能更进⼀步提⾼数据的保密性，这正是现在⾦融交易⽹络的流⾏做法。

下⾯是具体代码：（切记切记字符串转字节或字节转字符串时⼀定要加上编码，否则可能出现乱码）1import java.io.IOException;2import java.security.SecureRandom;34import javax.crypto.Cipher;5import javax.crypto.SecretKey;6import javax.crypto.SecretKeyFactory;7import javax.crypto.spec.DESKeySpec;89import sun.misc.BASE64Decoder;10import sun.misc.BASE64Encoder;1112/**13 * DES加密解密算法14 *15 * @author lifq16 * @date 2015-3-17 上午10:12:1117*/18public class DesUtil {1920private final static String DES = "DES";21private final static String ENCODE = "GBK";22private final static String defaultKey = "test1234";2324public static void main(String[] args) throws Exception {25 String data = "测试ss";26// System.err.println(encrypt(data, key));27// System.err.println(decrypt(encrypt(data, key), key));28 System.out.println(encrypt(data));29 System.out.println(decrypt(encrypt(data)));3031 }3233/**34 * 使⽤默认key 加密35 *36 * @return String37 * @author lifq38 * @date 2015-3-17 下午02:46:4339*/41byte[] bt = encrypt(data.getBytes(ENCODE), defaultKey.getBytes(ENCODE));42 String strs = new BASE64Encoder().encode(bt);43return strs;44 }4546/**47 * 使⽤默认key 解密48 *49 * @return String50 * @author lifq51 * @date 2015-3-17 下午02:49:5252*/53public static String decrypt(String data) throws IOException, Exception {54if (data == null)55return null;56 BASE64Decoder decoder = new BASE64Decoder();57byte[] buf = decoder.decodeBuffer(data);58byte[] bt = decrypt(buf, defaultKey.getBytes(ENCODE));59return new String(bt, ENCODE);60 }6162/**63 * Description 根据键值进⾏加密64 *65 * @param data66 * @param key67 * 加密键byte数组68 * @return69 * @throws Exception70*/71public static String encrypt(String data, String key) throws Exception {72byte[] bt = encrypt(data.getBytes(ENCODE), defaultKey.getBytes(ENCODE));73 String strs = new BASE64Encoder().encode(bt);74return strs;75 }7677/**78 * Description 根据键值进⾏解密79 *80 * @param data81 * @param key82 * 加密键byte数组83 * @return84 * @throws IOException85 * @throws Exception86*/87public static String decrypt(String data, String key) throws IOException,88 Exception {89if (data == null)90return null;91 BASE64Decoder decoder = new BASE64Decoder();92byte[] buf = decoder.decodeBuffer(data);93byte[] bt = decrypt(buf, key.getBytes(ENCODE));94return new String(bt, ENCODE);95 }9698 * Description 根据键值进⾏加密99 *100 * @param data101 * @param key102 * 加密键byte数组103 * @return104 * @throws Exception105*/106private static byte[] encrypt(byte[] data, byte[] key) throws Exception { 107// ⽣成⼀个可信任的随机数源108 SecureRandom sr = new SecureRandom();109110// 从原始密钥数据创建DESKeySpec对象111 DESKeySpec dks = new DESKeySpec(key);112113// 创建⼀个密钥⼯⼚，然后⽤它把DESKeySpec转换成SecretKey对象114 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES); 115 SecretKey securekey = keyFactory.generateSecret(dks);116117// Cipher对象实际完成加密操作118 Cipher cipher = Cipher.getInstance(DES);119120// ⽤密钥初始化Cipher对象121 cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);122123return cipher.doFinal(data);124 }125126/**127 * Description 根据键值进⾏解密128 *129 * @param data130 * @param key131 * 加密键byte数组132 * @return133 * @throws Exception134*/135private static byte[] decrypt(byte[] data, byte[] key) throws Exception { 136// ⽣成⼀个可信任的随机数源137 SecureRandom sr = new SecureRandom();138139// 从原始密钥数据创建DESKeySpec对象140 DESKeySpec dks = new DESKeySpec(key);141142// 创建⼀个密钥⼯⼚，然后⽤它把DESKeySpec转换成SecretKey对象143 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES); 144 SecretKey securekey = keyFactory.generateSecret(dks);145146// Cipher对象实际完成解密操作147 Cipher cipher = Cipher.getInstance(DES);148149// ⽤密钥初始化Cipher对象150 cipher.init(Cipher.DECRYPT_MODE, securekey, sr);151152return cipher.doFinal(data);153 }。

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文件加密解密程序，实现对文件进行加密和解密的功能。

具体要求如下：1. 提供用户界面，允许用户选择加密或解密操作；2. 用户可以选择要加密或解密的文件，支持多种文件类型；3. 支持不同的加密算法，如AES、DES等；4. 加密后的文件需要保存到指定的位置；5. 解密后的文件需要保存到指定的位置；6. 提供错误处理机制，如文件不存在、加密解密失败等情况的处理。

二、设计思路根据任务描述，我们可以将程序设计分为以下几个模块：1. 用户界面模块：设计一个简单直观的用户界面，提供加密和解密操作的选项，以及选择文件和保存位置的功能。

2. 加密模块：实现文件加密功能，根据用户选择的加密算法对文件进行加密操作，并将加密后的文件保存到指定位置。

3. 解密模块：实现文件解密功能，根据用户选择的加密算法对文件进行解密操作，并将解密后的文件保存到指定位置。

4. 错误处理模块：处理文件不存在、加密解密失败等错误情况，给出相应的提示信息。

三、实现步骤1. 用户界面设计：- 使用JAVA图形界面库（如Swing、JavaFX等）创建一个窗口，包含加密和解密的选项按钮、选择文件和保存位置的按钮，以及相应的文本框和标签。

- 为按钮添加监听器，实现相应的操作。

2. 加密模块设计：- 根据用户选择的加密算法（如AES、DES等），使用相应的JAVA加密库实现文件加密功能。

- 读取用户选择的文件，将文件内容进行加密，并将加密后的内容保存到指定位置。

3. 解密模块设计：- 根据用户选择的加密算法，使用相应的JAVA解密库实现文件解密功能。

java DES加密文件上传数据库,下载文件解密

Java上传数据库加密文件，下载解密文件package com.IBM.basis.JiaMiUtil;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.security.InvalidKeyException;import java.security.Key;import java.security.NoSuchAlgorithmException;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.CipherInputStream;import javax.crypto.IllegalBlockSizeException;import javax.crypto.NoSuchPaddingException;import javax.crypto.spec.SecretKeySpec;import com.IBM.basis.SftpUtil.jdbc.JdbcOracleUtil;public class EncrypDes {/*** 固定key** @return*/public Key getKey() {Key deskey = null;try {// 固定密钥byte[] buffer = new byte[] { 0x47, 0x33, 0x43, 0x4D, 0x4F, 0x50,0x31, 0x32 };deskey = (Key) new SecretKeySpec(buffer, "DES");} catch (Exception e) {throw new RuntimeException("Error initializing SqlMap class. Cause: " + e);}return deskey;}/*** 加密01* @param src* @param deskey* @return* @throws InvalidKeyException* @throws IllegalBlockSizeException* @throws BadPaddingException* @throws NoSuchAlgorithmException* @throws NoSuchPaddingException*/public byte[] Encrytor(byte[] src, Key deskey)throws InvalidKeyException, IllegalBlockSizeException,BadPaddingException, NoSuchAlgorithmException,NoSuchPaddingException {Cipher c = Cipher.getInstance("DES/ECB/NoPadding");// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式c.init(Cipher.ENCRYPT_MODE, deskey);byte[] doFinal = c.doFinal(src);return doFinal;}/*** 加密方法02* @param is* @param deskey* @return* @throws InvalidKeyException* @throws IllegalBlockSizeException* @throws BadPaddingException* @throws NoSuchAlgorithmException* @throws NoSuchPaddingException*/public CipherInputStream Encrytor02(InputStream is, Key deskey)throws InvalidKeyException, IllegalBlockSizeException,BadPaddingException, NoSuchAlgorithmException,NoSuchPaddingException {Cipher c = Cipher.getInstance("DES/ECB/NoPadding");// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式c.init(Cipher.ENCRYPT_MODE, deskey);CipherInputStream cis = new CipherInputStream(is, c);return cis;}/*** 对字符串解密** @param buff* @return* @throws InvalidKeyException* @throws IllegalBlockSizeException* @throws BadPaddingException* @throws NoSuchPaddingException* @throws NoSuchAlgorithmException*/public byte[] Decryptor(byte[] buff, Key deskey)throws InvalidKeyException, IllegalBlockSizeException,BadPaddingException, NoSuchAlgorithmException,NoSuchPaddingException {Cipher c = Cipher.getInstance("DES/ECB/NoPadding");// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式c.init(Cipher.DECRYPT_MODE, deskey);byte[] doFinal = c.doFinal(buff);return doFinal;}/*** InputStream 转byte[]* @param iStrm* @return* @throws IOException*/public byte[] InputStreamToByte(InputStream iStrm) throws IOException { ByteArrayOutputStream bytestream = new ByteArrayOutputStream();int ch;byte[] buf = new byte[1024];while ((ch = iStrm.read()) != -1){bytestream.write(buf, 0, ch);}byte imgdata[]=bytestream.toByteArray();bytestream.close();return imgdata;}public static void main(String[] args) throws Exception {EncrypDes encrypDes = new EncrypDes();Key key = encrypDes.getKey();System.out.println(key);long sqlstart = System.currentTimeMillis();// 开始时间File file = new File("D:/Icon.txt");FileInputStream in = new FileInputStream(file);CipherInputStream cin = encrypDes.Encrytor02(in, key);Connection con = null;// 创建一个数据库连接PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用StatementResultSet result = null;// 创建一个结果集对象// /*try {con = JdbcOracleUtil.getConn02("");System.out.println(con != null ? "成功" : "失败" + "连接成功！");String sql = "Insert INTO FI_FILE (ID,FILECONTENT) values ( FIFILE_SEQ.nextVal ,? ) ";pre = con.prepareStatement(sql);ByteArrayOutputStream bAOutputStream = new ByteArrayOutputStream();int ch;while ((ch = cin.read()) != -1) {bAOutputStream.write(ch);}byte data[] = bAOutputStream.toByteArray();System.out.println(data);bAOutputStream.close();pre.setBytes(1, data);// 4.执行语句int i = pre.executeUpdate();System.out.println(i);} catch (Exception e) {e.printStackTrace();} finally {try {// 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源// 注意关闭的顺序，最后使用的最先关闭if (result != null)result.close();if (pre != null)pre.close();if (con != null)con.close();System.out.println("数据库连接已关闭！");} catch (Exception e) {e.printStackTrace();}}long sqlend = System.currentTimeMillis(); // 结束时间System.out.println("上传文件用时：" + (sqlend - sqlstart) / 1000 + " s");System.out.println("上传文件用时：" + (sqlend - sqlstart) + " ms ");// */// /*try {con = JdbcOracleUtil.getConn02("");System.out.println(con != null ? "成功" : "失败" + "连接成功！");String sql = "select * from Fi_File where ID=16";// String sql="select * from Fi_Fileinfo where fileid=97 ";pre = con.prepareStatement(sql);// 4.执行语句ResultSet reset = pre.executeQuery();byte[] bis = null;while (reset.next()) {bis = reset.getBytes("FILECONTENT");}byte[] doFinal = encrypDes.Decryptor(bis, key);// Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");// cipher.init(Cipher.DECRYPT_MODE, key);// byte[] doFinal = cipher.doFinal(bis);System.out.println(doFinal);System.out.println(new String(doFinal, "GB2312"));} catch (Exception e) {System.out.println(e);} finally {try {// 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源// 注意关闭的顺序，最后使用的最先关闭if (result != null)result.close();if (pre != null)pre.close();if (con != null)con.close();System.out.println("数据库连接已关闭！");} catch (Exception e) {e.printStackTrace();}}long sqlend02 = System.currentTimeMillis(); // 结束时间System.out.println("上传文件用时：" + (sqlend02 - sqlstart) / 1000 + " s");System.out.println("上传文件用时：" + (sqlend02 - sqlstart) + " ms ");// */}}。

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

10, 11, 12, 13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1 }; // 48 private static final int[] P = { 7, 16, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 9, 3, 19, 13, 30, 6, 22, 11, 4, 25 }; // 32 private static final int[][][] S_Box = { //S-盒 {// S_Box[1] { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 }, { 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 }, { 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 }, { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } }, { // S_Box[2] { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 }, { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 }, { 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 }, { 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } }, { // S_Box[3] { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 }, { 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 }, { 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 }, { 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } }, { // S_Box[4] { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 }, { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 }, { 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 }, { 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } }, { // S_Box[5] { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 }, { 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 }, { 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 }, { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } }, { // S_Box[6] { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 }, { 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 }, { 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 }, { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } }, { // S_Box[7]
// 初试化密钥数组 private void KeyInitialize(int[] key, int[][] keyarray) { int i; int j; int[] K0 = new int[56];// 特别注意：xxx[IP[i]-1]等类似变换 for (i = 0; i < 56; i++) { K0[i] = key[PC_1[i] - 1];// 密钥进行PC-1变换 } for (i = 0; i < 16; i++) { LeftBitMove(K0, LeftMove[i]); // 特别注意：xxx[IP[i]-1]等类似变换 for (j = 0; j < 48; j++) { keyarray[i][j] = K0[PC_2[j] - 1]; // 生成子密钥keyarray[i][j] } } } // 执行加密解密操作,flag,为1加密，为0解密 private byte[] Encrypt(int[] timeData, int flag, int[][] keyarray) { int i; byte[] encrypt = new byte[8]; int flags = flag; int[] M = new int[64]; int[] MIP_1 = new int[64]; // 特别注意：xxx[IP[i]-1]等类似变换 for (i = 0; i < 64; i++) { M[i] = timeData[IP[i] - 1]; // 明文IP变换 } if (flags == 1) { // 加密 for (i = 0; i < 16; i++) { LoopF(M, i, flags, keyarray); } } else if (flags == 0) { // 解密 for (i = 15; i > -1; i--) { LoopF(M, i, flags, keyarray); } }
{ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 }, { 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 }, { 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 }, { 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } }, { // S_Box[8] { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 }, { 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 }, { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8Байду номын сангаас}, { 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } } }; // 左移位置列表 private static final int[] LeftMove = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; byte[] bytekey; //密码的二进制数组 public SY_1_DesUtil(String strKey) { this.bytekey = strKey.getBytes(); } private byte[] UnitDes(byte[] des_key, byte[] des_data, int flag) { // 检测输入参数格式是否正确，错误直接返回空值（null） if ((des_key.length != 8) || (des_data.length != 8)|| ((flag != 1) && (flag != 0))) { throw new RuntimeException("Data Format Error !"); } int flags = flag;// 二进制加密密钥 int[] keydata = new int[64];// 二进制加密数据 int[] encryptdata = new int[64]; // 加密操作完成后的字节数组 byte[] EncryptCode = new byte[8];// 密钥初试化成二维数组 int[][] KeyArray = new int[16][48];// 将密钥字节数组转换成二进制字节数组 keydata = ReadDataToBirnaryIntArray(des_key);// 将加密数据字节数组转换成二进制字节数组 encryptdata = ReadDataToBirnaryIntArray(des_data);// 初试化密钥为二维密钥数组 KeyInitialize(keydata, KeyArray); // 执行加密解密操作 EncryptCode = Encrypt(encryptdata, flags, KeyArray); return EncryptCode; }
public class SY_1_DesUtil { // 声明常量字节数组 private static final int[] IP = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7 }; // 64 private static final int[] IP_1 = { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 }; // 64 private static final int[] PC_1 = { 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4 }; // 56 private static final int[] PC_2 = { 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32 }; // 48 private static final int[] E = { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9,