在JAVA中使用DES算法加密数据

        在JDK的javax.crypto 的包中提供了对一些通用算法的加密解密的支持，本文简介一下使用DES算法来对数据加密解密。通常是数据加密方用密钥将数据加密，数据解密方用同样的密钥将数据解密。这个密钥是包含8位byte的一个二进制的文件，加密解密方可以是任何开发语言。

        用JAVA生成一个key并保存到一个二进制文件中去的方法如下:

    public static void saveBytePriveKey(String file) {

        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("DES");

            SecretKey key = keyGen.generateKey();// 生成私钥Key

            FileOutputStream fop = new FileOutputStream(file);
            fop.write(key.getEncoded());
            fop.close();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

     从密钥文件中读取内容生成密钥:

    public static SecretKey getBytePriveKey(String file) throws Exception {
        File keyf = new File(file);
        long length = keyf.length();
        byte[] bytes = new byte[(int) length];

        FileInputStream fis = new FileInputStream(keyf);

        // Read in the bytes
        int offset = 0;
        int numRead = 0;

        while (offset < bytes.length && (numRead = fis.read(bytes, offset, bytes.length - offset)) >= 0) {
            offset += numRead;
        }
        DESKeySpec dks = new DESKeySpec(bytes);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);

        return key;
    }

        对文件进行加密，对文件的操作应该是以流的方式，加密后的数据是一个二进制流，它可能不能被对应到任何编码的String，所以在操作过程中不应该将加密后的byte数据转换为String。将一个文件加密为另一个文件的代码如下：

    public static void encryptFile(String plainFile, String encryptedFile, String keyFile) {
        try {

            SecretKey key = getBytePriveKey(keyFile);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE, key);

            FileInputStream fis = new FileInputStream(plainFile);
            FileOutputStream fos = new FileOutputStream(encryptedFile);
            crypt(fis, fos, cipher);

            fis.close();
            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException,
            GeneralSecurityException {
        int blockSize = cipher.getBlockSize();
        int outputSize = cipher.getOutputSize(blockSize);
        System.out.println("blockSize " + blockSize + " outputSize" + outputSize);

        byte[] inBytes = new byte[blockSize];
        byte[] outBytes = new byte[outputSize];

        int inLength = 0;
        boolean more = true;
        while (more) {
            inLength = in.read(inBytes);
            if (inLength == blockSize) {
                int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
                out.write(outBytes, 0, outLength);
            } else {
                more = false;
            }
        }
        if (inLength > 0)
            outBytes = cipher.doFinal(inBytes, 0, inLength);
        else
            outBytes = cipher.doFinal();
        out.write(outBytes);
    }

      同样，在解密过程中，对数据也应该以流的方式：

    public static void decryptFile(String encryptedFile, String decryptedFile, String keyFile) {
        try {

            SecretKey key = getBytePriveKey(keyFile);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE, key);

            FileInputStream fis = new FileInputStream(encryptedFile);
            FileOutputStream fos = new FileOutputStream(decryptedFile);
            crypt(fis, fos, cipher);

            fis.close();
            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

        如果是想把很多String一行一行的加密后保存到一个文件，应该先把这些String保存到一个中间文件，然后把中间文件以流的方式读入，以加密文件的方式进行。我尝试着把

加密一个String就写到文件中，但是发现最后解密的时候会有问题。

下面是整个类的源代码：

package com.test.endecrypt;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public class DESCrypter {

    private static String bytekeyfile = "d://temp//bytekeyfile";

    private static String originalfile = "d://temp//originalfile";
    private static String encryptedfile = "d://temp//encryptedfile";
    private static String decryptedfile = "d://temp//decryptedfile";

    public static void main(String args[]) {

        saveBytePriveKey(bytekeyfile);

        encryptFile(originalfile, encryptedfile, bytekeyfile);

        decryptFile(encryptedfile, decryptedfile, bytekeyfile);

        String[] strings = { "要加密的串 the text to be encrypt", "AAAAAAAAAAA", "要加密的串 the text to be encrypt" };
        encryptStringsTofile(strings, encryptedfile, bytekeyfile);
        decryptFile(encryptedfile, decryptedfile, bytekeyfile);
    }

    public static void encryptFile(String plainFile, String encryptedFile, String keyFile) {
        try {

            SecretKey key = getBytePriveKey(keyFile);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE, key);

            FileInputStream fis = new FileInputStream(plainFile);
            FileOutputStream fos = new FileOutputStream(encryptedFile);
            crypt(fis, fos, cipher);

            fis.close();
            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void encryptStringsTofile(String[] strings, String encryptedFile, String keyFile) {
        try {

            SecretKey key = getBytePriveKey(keyFile);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE, key);

            FileOutputStream fos = new FileOutputStream(encryptedFile);
            crypt(strings, fos, cipher);

            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException,
            GeneralSecurityException {
        int blockSize = cipher.getBlockSize();
        int outputSize = cipher.getOutputSize(blockSize);
        System.out.println("blockSize " + blockSize + " outputSize" + outputSize);

        byte[] inBytes = new byte[blockSize];
        byte[] outBytes = new byte[outputSize];

        int inLength = 0;
        boolean more = true;
        while (more) {
            inLength = in.read(inBytes);
            if (inLength == blockSize) {
                int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
                out.write(outBytes, 0, outLength);
            } else {
                more = false;
            }
        }
        if (inLength > 0)
            outBytes = cipher.doFinal(inBytes, 0, inLength);
        else
            outBytes = cipher.doFinal();
        out.write(outBytes);
    }

    public static void crypt(String strings[], OutputStream out, Cipher cipher) throws IOException,
            GeneralSecurityException {
        for (String str : strings) {
            byte[] encryptedBytes = encrypt(str + "\r\n", "UTF8", cipher);
            out.write(encryptedBytes);
        }

    }

    public static byte[] encrypt(String in, String strEncode, Cipher cipher) throws IOException,
            GeneralSecurityException {
        byte[] originalBytes = in.getBytes(strEncode);
        byte[] encryptedBytes = cipher.doFinal(originalBytes);

        return encryptedBytes;
    }

    public static void decryptFile(String encryptedFile, String decryptedFile, String keyFile) {
        try {

            SecretKey key = getBytePriveKey(keyFile);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE, key);

            FileInputStream fis = new FileInputStream(encryptedFile);
            FileOutputStream fos = new FileOutputStream(decryptedFile);
            crypt(fis, fos, cipher);

            fis.close();
            fos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static SecretKey createSecretKey(String algorithm) {
        // 声明KeyGenerator对象
        KeyGenerator keygen;
        // 声明 密钥对象
        SecretKey deskey = null;
        try {
            // 返回生成指定算法的秘密密钥的 KeyGenerator 对象
            keygen = KeyGenerator.getInstance(algorithm);
            // 生成一个密钥
            deskey = keygen.generateKey();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        // 返回密匙
        return deskey;
    }

    // 把Key 写到文件中：生成一个私有Key对象，保存在文件中
    public static void saveBytePriveKey(String file) {

        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("DES");

            SecretKey key = keyGen.generateKey();// 生成私钥Key

            FileOutputStream fop = new FileOutputStream(file);
            fop.write(key.getEncoded());
            fop.close();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
    public static SecretKey getBytePriveKey(String file) throws Exception {
        File keyf = new File(file);
        long length = keyf.length();
        byte[] bytes = new byte[(int) length];

        FileInputStream fis = new FileInputStream(keyf);

        // Read in the bytes
        int offset = 0;
        int numRead = 0;

        while (offset < bytes.length && (numRead = fis.read(bytes, offset, bytes.length - offset)) >= 0) {
            offset += numRead;
        }
        DESKeySpec dks = new DESKeySpec(bytes);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);

        return key;
    }

}