DES加密解密

自己留着，解释如下

package com.jicheng.android.project.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;

import javax.crypto.Cipher;
import javax.crypto.CipherOutputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
*
* @Package: com.jicheng.android.project.utils
* @ClassName: DESEncrypter
* @Description: TODO(这里用一句话描述这个类的作用)
* @author
* @date 2016年4月8日 上午11:23:26
*
*/
public class DESEncrypter
{
private final static String DES = “DES”;

private final static int DEFAULT_READ_WRITE_BLOCK_BUFFER_SIZE = 1024;

/**
 * 秘钥
 */
private static byte[] iv = "1234567812345678".getBytes();

/**
 * Description 根据键值进行加密
 * 
 * @param data
 * @param key 加密键byte数组
 * @return
 * @throws Exception
 */
public static void encrypt(byte[] key, InputStream in, OutputStream out)
    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);
    out = new CipherOutputStream(out, cipher);
    int count = 0;
    byte[] buffer = new byte[DEFAULT_READ_WRITE_BLOCK_BUFFER_SIZE];
    while ((count = in.read(buffer)) >= 0)
    {
        out.write(buffer, 0, count);
    }
    out.close();

}

/**
 * Description 根据键值进行解密
 * 
 * @param data
 * @param key 加密键byte数组
 * @return
 * @throws Exception
 */
public static void decrypt(byte[] key, InputStream in, OutputStream out)
    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);

    out = new CipherOutputStream(out, cipher);
    int count = 0;
    byte[] buffer = new byte[DEFAULT_READ_WRITE_BLOCK_BUFFER_SIZE];
    while ((count = in.read(buffer)) >= 0)
    {
        out.write(buffer, 0, count);
    }

    out.close();

}

public static void main(String[] args)
{
    File inFile = new File("TheTest.mp4");
    File outFile = new File("encrypt_file.mp4");
    File outFile_dec = new File("decrypt_file.mp4");

    try
    {
        // 加密
        // encrypt(iv, new FileInputStream(inFile), new FileOutputStream(outFile));
        // 解密
        decrypt(iv, new FileInputStream(outFile), new FileOutputStream(outFile_dec));
    }
    catch (FileNotFoundException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (Exception e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();

        System.out.println("i=" + "=========printStackTrace===============t");
    }

}

}