java课程设计报告 文件加密与解密—Java课程设计报告
导读：就爱阅读网友为您分享以下“文件加密与解密—Java课程设计报告”的资讯，希望对您有所帮助，感谢您对92的支持!
}                            }            } while(SealedObj2!=null) {    } ObjIS2.close(); fis2.close(); fos2.flush(); fos2.close(); return true; buffer2=(byte[])SealedObj2.getObject(SecKey2); fos2.write(buffer2); SealedObj2=(SealedObject)ObjIS2.readObject(); catch(java.security.NoSuchAlgorithmException e1) {   } catch(java.io.EOFException e2) {   } catch(java.lang.Exception e3) {   } e3.printStackTrace(); return false; System.out.println("解密完成！"); return true; e1.printStackTrace(); return false;
JAVA课程设计
题目： 文件的加密与解密
姓    名：                      学    号：                        班    级:                       日    期：
目  录
一、设计思路 ........................................... 3 二、具体实现 ........................................... 3 三、运行调试与分析讨论 ................................. 8 四、设计体会与小结 .................................... 11 五、参考文献 .......................................... 12 六、附录 .............................................. 12
一、 设计思路

最近遇上在搭建SSM框架的时候遇上数据库配置文件需加密的需求，网上搜罗资料自己写了一份。主要是给自己以后好找！同时也希望能帮助大家
这里是根据DES方式进行加密解密的类
package net.merise.mir.core.encrypt;
 
import java.io.IOException;
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;
import sun.misc.BASE64Encoder;
 
public class DESUtil {
 
    private final static String DES = "DES";
 
    public static void main(String[] args) throws Exception {
        String data = "mirundba";
        String key = "@abcdef@";
        System.err.println(encrypt(data, key));
    }
     
    /**
     * Description 根据键值进行加密
     * @param data 
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key) throws Exception {
        byte[] bt = encrypt(data.getBytes(), key.getBytes());
        String strs = new BASE64Encoder().encode(bt);
        return strs;
    }
 
    /**
     * Description 根据键值进行解密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws IOException,
            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);
    }
 
    /**
     * Description 根据键值进行加密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(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.ENCRYPT_MODE, securekey, sr);
 
        return cipher.doFinal(data);
    }
     
     
    /**
     * 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);
    }
}
这里是解密配置文件的类
<pre name="code" class="java">package net.merise.mir.core.encrypt;

import java.util.Properties;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

public class DBConfigurer extends PropertyPlaceholderConfigurer {

	private final static String key = "@abcdef@";
	private final static String URL = "url";
	private final static String USER = "user";
	private final static String PASSWORD = "password";

	@Override
	protected void processProperties(
			ConfigurableListableBeanFactory beanFactory, Properties props)
			throws BeansException {

		String url = props.getProperty("url");
		if (url != null)
			try {
				props.setProperty(URL, DESUtil.decrypt(url, key));
			} catch (Exception e) {
				e.printStackTrace();
			}
		String user = props.getProperty("user");
		if (user != null)
			try {
				props.setProperty(USER, DESUtil.decrypt(user, key));
			} catch (Exception e) {
				e.printStackTrace();
			}
		
		String password = props.getProperty("password");
		if (password != null)
			try {
				props.setProperty(PASSWORD, DESUtil.decrypt(password, key));
			} catch (Exception e) {
				e.printStackTrace();
			}
		super.processProperties(beanFactory, props);
	}
}



<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">接下来是配置Spring MVC</span>

	<!-- 属性文件读入,用于加密数据库配置文件 -->  
    <bean id="propertyConfigurer" class="net.maventec.mir.core.encrypt.DBConfigurer">  
        <property name="locations">  
            <list>  
                <value>classpath:config/db.properties</value>  
            </list>  
        </property>  
    </bean>
这是加密的配置文件

#数据库连接
driver=com.mysql.jdbc.Driver
url=aROE3XZWJAL1u0RpwMvhS1v0f8QyifbqaJDbkGu+b5iD8c/Pi3Ri+fSXkD9/1u1DYiKpIhgqce+aQfIw4cMq0g==
user=ZxV4aL2ZlUaudDFZJtxyAQ==
password=ZxV4aL2ZlUaudDFZJtxyAQ==

调用的配置文件

	<!-- 配置数据源 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${url}" />
		<property name="user" value="${user}" />
		<property name="driverClass" value="${driver}" />
		<property name="password" value="${password}" />

		<property name="minPoolSize" value="5" />
		<property name="maxPoolSize" value="50" />
		<property name="initialPoolSize" value="10" />
	</bean>


注意的是这两个的顺序不能反


	<!-- 属性文件读入,用于加密数据库配置文件 -->
	<bean id="propertyConfigurer" class="net.merise.mir.core.encrypt.DBConfigurer">
		<property name="locations">
			<list>
				<value>classpath:config/db.properties</value>
			</list>
		</property>
	</bean>
	
	<!-- 配置需要交给spring扫描管理的文件,一般是项目的配置文件（由context提供） -->
	<context:property-placeholder location="classpath:config/db.properties" />

程序中使用了.properties文件作为参数配置文档，好处是灵活配置各项参数
一旦对数据库的一些参数进行了配置，势必涉及数据库的IP，端口，用户名和密码
properties文件全是unicode编码明文存储，程序打包交付后，其他人能够很容易使用解压软件打开jar查看你的.properties文件
所以一些敏感变量需要加密处理
首先需要了解一些基本的加密算法，比如MD5，比如DES和RSA
MD5是一种不可逆的加密算法，使用散列后特征码的方式表现需要加密的字符或者文件，常用在系统登陆的密码比对中
将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测试里面写加密的语句用来对数据库密码进行加密。

1 下面用DES对称加密算法(设定一个密钥，然后对所有的数据进行加密)来简单举个例子。2
3 首先，生成一个密钥KEY。4 我把它保存到key.txt中。这个文件就象是一把钥匙。谁拥有它，谁就能解开我们的类文件。代码参考如下：5 packagecom.neusoft.jiami;6 importJava.io.File;7 importjava.io.FileOutputStream;8 importjava.security.SecureRandom;9 importjavax.crypto.KeyGenerator;10 importjavax.crypto.SecretKey;11 classKey {12     privateString keyName;13     publicKey(String keyName) {14         this.keyName =keyName;15 }16     public void createKey(String keyName) throwsException {17         //创建一个可信任的随机数源，DES算法需要
18          SecureRandom sr = newSecureRandom();19         //用DES算法创建一个KeyGenerator对象
20          KeyGenerator kg = KeyGenerator.getInstance("DES");21         //初始化此密钥生成器,使其具有确定的密钥长度
22 kg.init(sr);23         //生成密匙
24          SecretKey key =kg.generateKey();25         //获取密钥数据
26         byte rawKeyData[] =key.getEncoded();27         //将获取到密钥数据保存到文件中，待解密时使用
28          FileOutputStream fo = new FileOutputStream(newFile(keyName));29 fo.write(rawKeyData);30 }31     public static voidmain(String args[]) {32         try{33             new Key("key.txt");34          } catch(Exception e) {35 e.printStackTrace();36 }37 }38 }39 第二步，对我们所要进行加密的类文件进行加密。40 比如我有一个DigestPass类，已经被正常编译好生成DigestPass.class文件。此时，这个类文件是任何人都可以用的。因为系统的类加载器可以自动的加载它。那么下一步，我们要做的就是把这个类文件加密。使系统的类加载器无法读取到正确的字节码文件。参考代码如下：41 packagecom.neusoft.jiami;42 importjava.io.File;43 importjava.io.FileInputStream;44 importjava.io.FileOutputStream;45 importjava.security.SecureRandom;46 importjavax.crypto.Cipher;47 importjavax.crypto.SecretKey;48 importjavax.crypto.SecretKeyFactory;49 importjavax.crypto.spec.DESKeySpec;50 public classJiaMi {51     public static void main(String[] args) throwsException {52         //DES算法要求有一个可信任的随机数源
53          SecureRandom sr = newSecureRandom();54         //获得密匙数据
55          FileInputStream fi = new FileInputStream(new File("key.txt"));56         byte rawKeyData[] = new byte[fi.available()];57 fi.read(rawKeyData);58 fi.close();59         //从原始密匙数据创建DESKeySpec对象
60          DESKeySpec dks = newDESKeySpec(rawKeyData);61         //创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
62          SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);63         //Cipher对象实际完成加密操作
64          Cipher cipher = Cipher.getInstance("DES");65         //用密匙初始化Cipher对象
66 cipher.init(Cipher.ENCRYPT_MODE, key, sr);67         //现在，获取要加密的文件数据
68          FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));69         byte data[] = new byte[fi2.available()];70 fi2.read(data);71 fi2.close();72         //正式执行加密操作
73         byte encryptedData[] =cipher.doFinal(data);74         //用加密后的数据覆盖原文件
75          FileOutputStream fo = new FileOutputStream(new File("DigestPass.class"));76 fo.write(encryptedData);77 fo.close();78 }79 }80 第三步，用自定义的CLASSLOADER进行加载。参考代码如下：81 packagecom.neusoft.jiami;82 importjava.io.File;83 importjava.io.FileInputStream;84 importjava.io.FileOutputStream;85 importjava.security.SecureRandom;86 importjavax.crypto.Cipher;87 importjavax.crypto.SecretKey;88 importjavax.crypto.SecretKeyFactory;89 importjavax.crypto.spec.DESKeySpec;90 importcom.neusoft.classloader.MyClassLoader;91 public classJieMi {92     public static void main(String[] args) throwsException {93         //DES算法要求有一个可信任的随机数源
94          SecureRandom sr = newSecureRandom();95         //获得密匙数据
96          FileInputStream fi = new FileInputStream(new File("key.txt"));97         byte rawKeyData[] = new byte[fi.available()];//= new byte[5];
98 fi.read(rawKeyData);99 fi.close();100         //从原始密匙数据创建一个DESKeySpec对象
101          DESKeySpec dks = newDESKeySpec(rawKeyData);102         //创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象
103          SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);104         //Cipher对象实际完成解密操作
105          Cipher cipher = Cipher.getInstance("DES");106         //用密匙初始化Cipher对象
107 cipher.init(Cipher.DECRYPT_MODE, key, sr);108         //现在，获取数据并解密
109          FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));110         byte encryptedData[] = new byte[fi2.available()];111 fi2.read(encryptedData);112 fi2.close();113         //正式执行解密操作
114         byte decryptedData[] =cipher.doFinal(encryptedData);115         //这时把数据还原成原有的类文件116         //FileOutputStream fo = new FileOutputStream(new117         //File("DigestPass.class"));118         //fo.write(decryptedData);119         //用解密后的数据加载类并应用
120          MyClassloader mcl = new MyClassloader("E:/");121          Class cl = mcl.loadClass(decryptedData, "com.neusoft.jiami.DigestPass");122          DigestPass dp =cl.newInstance();123 }124 }