java加密 des

DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。
　　DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。
import java.security.Key;  
import java.security.SecureRandom;  
 
import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
import javax.crypto.SecretKeyFactory;  
import javax.crypto.spec.DESKeySpec;  
/** 
 * DES安全编码组件 
 *  
 * <pre> 
 * 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR) 
 * DES                  key size must be equal to 56 
 * DESede(TripleDES)    key size must be equal to 112 or 168 
 * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
 * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
 * RC2                  key size must be between 40 and 1024 bits 
 * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
 * 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html 
 * </pre> 
 *  
 * @author 梁栋 
 * @version 1.0 
 * @since 1.0 
 */ 

public class DESTest  extends Coder {  
    /** 
     * ALGORITHM 算法 <br> 
     * 可替换为以下任意一种算法，同时key值的size相应改变。 
     *  
     * <pre> 
     * DES                  key size must be equal to 56 
     * DESede(TripleDES)    key size must be equal to 112 or 168 
     * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
     * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
     * RC2                  key size must be between 40 and 1024 bits 
     * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
     * </pre> 
     *  
     * 在Key toKey(byte[] key)方法中使用下述代码 
     * <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换 
     * <code> 
     * DESKeySpec dks = new DESKeySpec(key); 
     * SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM); 
     * SecretKey secretKey = keyFactory.generateSecret(dks); 
     * </code> 
     */ 
    public static final String ALGORITHM = "DES";  
 
    /** 
     * 转换密钥<br> 
     *  
     * @param key 
     * @return 
     * @throws Exception 
     */ 
    private static Key toKey(byte[] key) throws Exception {  
        DESKeySpec dks = new DESKeySpec(key);  
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);  
        SecretKey secretKey = keyFactory.generateSecret(dks);  
 
        // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码  
        // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);  
        return secretKey;  
    }  
 
    /** 
     * 解密 
     *  
     * @param data 
     * @param key 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] decrypt(byte[] data, String key) throws Exception {  
        Key k = toKey(decryptBASE64(key));  
 
        Cipher cipher = Cipher.getInstance(ALGORITHM);  
        cipher.init(Cipher.DECRYPT_MODE, k);  
 
        return cipher.doFinal(data);  
    }  
 
    /** 
     * 加密 
     *  
     * @param data 
     * @param key 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] encrypt(byte[] data, String key) throws Exception {  
        Key k = toKey(decryptBASE64(key));  
        Cipher cipher = Cipher.getInstance(ALGORITHM);  
        cipher.init(Cipher.ENCRYPT_MODE, k);  
 
        return cipher.doFinal(data);  
    }  
 
    /** 
     * 生成密钥 
     *  
     * @return 
     * @throws Exception 
     */ 
    public static String initKey() throws Exception {  
        return initKey(null);  
    }  
 
    /** 
     * 生成密钥 
     *  
     * @param seed 
     * @return 
     * @throws Exception 
     */ 
    public static String initKey(String seed) throws Exception {  
        SecureRandom secureRandom = null;  
 
        if (seed != null) {  
            secureRandom = new SecureRandom(decryptBASE64(seed));  
        } else {  
            secureRandom = new SecureRandom();  
        }  
 
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);  
        kg.init(secureRandom);  
 
        SecretKey secretKey = kg.generateKey();  
 
        return encryptBASE64(secretKey.getEncoded());  
    }  

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

 }

}

测试：

import static org.junit.Assert.*;  
import org.junit.Test;  
public class DESCoderTest2 {
 @Test 
    public void test() throws Exception {  
        String inputStr = "DES";  
        String key = DESTest.initKey();  
        System.err.println("原文:/t" + inputStr);  
 
        System.err.println("密钥:/t" + key);  
 
        byte[] inputData = inputStr.getBytes();  
        inputData = DESTest.encrypt(inputData, key);  
 
        System.err.println("加密后:/t" + DESTest.encryptBASE64(inputData));  
 
        byte[] outputData = DESTest.decrypt(inputData, key);  
        String outputStr = new String(outputData);  
 
        System.err.println("解密后:/t" + outputStr);  
        assertEquals(inputStr, outputStr);  
    }  

}

 

按着我理解的意思来进行再次分析：

import static org.junit.Assert.*;  
import org.junit.Test;  
public class DESCoderTest {  
 
    @Test 
    public void test() throws Exception {  
        String inputStr = "DES";  
        String key = DESTest.initKey();  
        System.err.println("原文:/t" + inputStr);  
 
        System.err.println("密钥:/t" + key);  
 
        byte[] inputData = inputStr.getBytes();  
        inputData = DESTest.encrypt(inputData, key);  
 
        System.err.println("des加密后:/t" + new String(inputData));
        //进行加密
        String encryptstr = DESTest.encryptBASE64(inputData);
        System.err.println("base加密后:/t" + encryptstr);  
      
        //解密:
        byte []b = DESTest.decryptBASE64(encryptstr);
        System.err.println("base解密后:/t" + new String(b));
        byte[] outputData = DESTest.decrypt(inputData, key);  
        String outputStr = new String(outputData);  
 
        System.err.println("des解密后:/t" + outputStr);  
 
        assertEquals(inputStr, outputStr);  
    }  
}