Java拓展教程：文件DES加解密

Java拓展教程:文件加解密

Java中的加密解密技术

　　加密技术根据一般可以分为对称加密技术和非对称加密技术。对称加密技术属于传统的加密技术，它的加密和解密的密钥是相同的，它的优点是：运算速度快，加密强度高，可以通过硬件方式来实现，适合大批量数据的加密处理，它的缺点是：加密和解密由于使用相同的密匙，密匙的分发与保密比较困难，目前常用的对称加密技术有DES、3DES和AES加密算法。

　　非对称加密技术属于现代加密技术，它的加密与解密的密钥是不相同的，一个是私钥，一个是公钥，它的特点是：加密强度比较小，加密的速度比较慢，常用于数字签名和加密密钥，目前使用的非对称加密技术主要有RSA和ECC加密算法，其中1024位的RSA是目前使用最为广泛的非对称加密技术。

　　JAVA语言的安全性是十分出色的，在JAVA中通过“Sun-JCF”提供对各种加密技术的支持。在JAVA还可以安装其它公司的加密包，使用“SunjCF”所不支持的其它加密算法。早在JDKl.l中就已支持DES数据加密技术，在JDKl.5中支持DES、3DES、AES等对称加密技术，在非对称加密技术方面支持RSA技术。

Java中的数据加密类

类KeyGenerator

　　此类提供（对称）密钥生成器的功能。密钥生成器是使用此类的某个 getInstance 类方法构造的。KeyGenerator 对象可重复使用，也就是说，在生成密钥后，可以重复使用同一个 KeyGenerator 对象来生成更多的密钥。生成密钥的方式有两种：与算法无关的方式和特定于算法的方式。两者之间的唯一不同是对象的初始化。

• getlnstance(“加密算法字符串”)，用于设置要获得的密钥的加密算法
• init（），用于初始化对称加密的密钥对象
• generateKey（），从对称加密的密钥对象中取得密钥

类 KeyPairGenerator

　　KeyPairGenerator 类用于生成公钥和私钥对。密钥对生成器是使用 getInstance 工厂方法（返回一个给定类的实例的静态方法）构造的。特定算法的密钥对生成器可以创建能够与此算法一起使用的公钥/私钥对。它还可以将特定于算法的参数与每个生成的密钥关联。有两种生成密钥对的方式：与算法无关的方式和特定于算法的方式。两种方式的唯一区别在于对象的初始化。

• getlnstance(“非对称加密算法字符串”)，用于设置要获得的密钥的加密算法
• initialize(密钥长度)，用于初始化非对称加密的密钥对象
• generateKeyPair（），返回非对称密钥组对象
• getPublic（），从非对称密钥组中取得公钥
• geLPrivate（），从非对称密钥组中用于取得私钥

类Cipher

　　此类为加密和解密提供密码功能。是JAVA加密的主要类，用于按一定的算法对数据文件进行加密、解密、包装和返包装。它构成了 Java Cryptographic Extension (JCE) 框架的核心。

• getInstance(“加密算法字符串”)，用于设置要使用的加密算法
• Init(“类型”，密匙)，按提供的类型和密匙初始化加密对象
• getBLockSize（），用于返回加密算法的输入分组长度
• getOutputSize（），用于返回加密算法的输出分组长度
• update(inBytes,blockSize，outBytes)，对inBytes进行加密或解密处理，并将处理结果输出到outBytes中
• doFinal（），对要不足分组长度的数据进行填充处理

Java实现DES加解密过程

Java代码实现DES加解密

package demo;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.security.Key;
import java.util.ArrayList;
import java.util.List;

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.spec.SecretKeySpec;

/***
 * Des文件加密解密
 */
public class FileDeEncrypt {

    public FileDeEncrypt(String keyStr) {
        genKey(keyStr);
        initCipher();
    }

    private Key key;
    // 解密密码
    private Cipher cipherDecrypt;
    // 加密密码
    private Cipher cipherEncrypt;

    /**
     * 加密文件的核心
     *
     * @param srcFileName
     *            要加密的文件
     * @param destFileName
     *            加密后存放的文件名
     */
    public boolean encryptFile(String srcFileName, String destFileName) {
        try {
            InputStream is = new FileInputStream(srcFileName);
            OutputStream out = new FileOutputStream(destFileName);

            CipherInputStream cis = new CipherInputStream(is, cipherEncrypt);
            byte[] buffer = new byte[1024];
            int r;
            while ((r = cis.read(buffer)) > 0) {
                out.write(buffer, 0, r);
            }
            cis.close();
            is.close();
            out.close();
            //LOG.info("文件{}加密完成，加密后的文件是:{}", srcFileName, destFileName);
            return true;
        }
        catch (Exception e) {
            //LOG.error("加密文件{}出现异常", srcFileName, e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /***
     * 解密文件
     * @param fileName 解密文件名
     */
    public List<String> decryptFileContent(String fileName) {
        List<String> list = new ArrayList<String>();
        try {
            InputStream is = new FileInputStream(fileName);
            CipherInputStream cis = new CipherInputStream(is, cipherDecrypt);
            BufferedReader reader = new BufferedReader(new InputStreamReader(cis));
            String line = null;
            while ((line = reader.readLine()) != null) {
                list.add(line);
            }
            reader.close();
            cis.close();
            is.close();
            //LOG.info("文件{}解密完成", fileName);
        }
        catch (Exception e) {
            //LOG.error("解密文件{}出现异常", fileName, e.getMessage());
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 解密文件，返回reader
     * @param fileName
     * @return
     */
    public BufferedReader decryptFile(String fileName) {
        BufferedReader reader = null;
        try {
            InputStream is = new FileInputStream(fileName);
            CipherInputStream cis = new CipherInputStream(is, cipherDecrypt);
            reader = new BufferedReader(new InputStreamReader(cis));
        }
        catch (Exception e) {
            //LOG.error("解密文件{}出现异常", fileName, e.getMessage());
            e.printStackTrace();
        }
        return reader;
    }

    /**
     * 初始化加解密密码
     */
    private void initCipher() {
        try {
            // 加密的cipher
            cipherEncrypt = Cipher.getInstance("DES");
            cipherEncrypt.init(Cipher.ENCRYPT_MODE, key);
            // 解密的cipher
            cipherDecrypt = Cipher.getInstance("DES");
            cipherDecrypt.init(Cipher.DECRYPT_MODE, key);
        }
        catch (Exception e) {
            //LOG.info("加密初始化出现异常:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 自定义一个key
     *
     * @param keyRule 密钥
     */
    public void genKey(String keyRule) {
        // Key key = null;
        byte[] keyByte = keyRule.getBytes();
        // 创建一个空的八位数组,默认情况下为0
        byte[] byteTemp = new byte[8];
        // 将用户指定的规则转换成八位数组
        for (int i = 0; i < byteTemp.length && i < keyByte.length; i++) {
            byteTemp[i] = keyByte[i];
        }
        key = new SecretKeySpec(byteTemp, "DES"); //可以使用此类来根据一个字节数组构造一个 SecretKey
    }

    /***
     * 测试加密解密
     *
     * @param args
     */
    public static void main(String[] args) {
        FileDeEncrypt deEncrypt = new FileDeEncrypt("MRSABER");
        deEncrypt.encryptFile("C:\\Users\\MrSaber\\Desktop\\test.txt", "pom.bin");
        List<String> list = deEncrypt.decryptFileContent("pom.bin");
        for (String str : list) {
            System.out.println(str);
        }
    }
}