无线&移动互联网技术研发

换位思考·····
posts - 19, comments - 53, trackbacks - 0, articles - 283
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

DES 加密工具类（一）

Posted on 2009-05-29 12:12 Gavin.lee 阅读(718) 评论(0)  编辑  收藏 所属分类: java SE & EE
其实加密算法很多种，在开发过程中并不能全部用到，到目前，还没用过复杂的对称加密。基本上加密算法就下面一些，虽然还有好多没研究过，也贴下来，当参考吧。
    基本的单向加密算法：
  • BASE64 严格地说，属于编码格式，而非加密算法
  • MD5(Message Digest algorithm 5，信息摘要算法)                         ----非可逆加密
  • SHA(Secure Hash Algorithm，安全散列算法)                                ----非可逆加密
  • HMAC(Hash Message Authentication Code，散列消息鉴别码)     ----非可逆加密

    复杂的对称加密（DES、PBE）、非对称加密算法：
  • DES(Data Encryption Standard，数据加密算法)
  • PBE(Password-based encryption，基于密码验证)
  • RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
  • DH(Diffie-Hellman算法，密钥一致协议)
  • DSA(Digital Signature Algorithm，数字签名)
  • ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)

非可逆加密就是不能解密，其实是不可靠加密。

DES加密：“ DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密，如果Mode为加密，则用Key去把数据Data进行加密，生成Data的密码形式作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式作为DES的输出结果。在使用DES时，双方预先约定使用的”密码”即Key，然后用Key去加密数据；接收方得到密文后使用同样的Key解密得到原数据，这样便实现了安全性较高的数据传输。
DES的工作原理为：将明文分割成许多64位大小的块，每个块用64位密钥进行加密”

package com.Gavin.tools.util;

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; 
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;  
/**
 * 
 * @descripte DES coder 
 * @author Gavin.lee
 * @date 2009-6-1 22:19:57
 * @version 1.0
 */
public abstract class DESCoder{       
    public static final String ALGORITHM = "DES";   //指定算法为 DES  
    /**  
     * 转换密钥
     */  
    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;   
    }   
  
    /**  
     * 解密  
     */  
    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);   
    }   
  
    /**  
     * 加密  
     */  
    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);   
    }   
  
    /**  
     * 生成密钥  
     */  
    public static String initKey() throws Exception {   
        return initKey(null);   
    }   
  
    /**  
     * 生成密钥  
     */  
    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());   
    }   
    
    public static void main(String args[]) {
        try {
            String inputString = "doingjava";    //data
            
            String key = DESCoder.initKey();    //key
            
            byte[] inputData = inputString.getBytes();
            
            inputData = DESCoder.encrypt(inputData, key);    //encrypt            
            
            System.out.println(DESCoder.encryptBASE64(inputData));    
            
            byte[] outputData = DESCoder.decrypt(inputData, key);    //decrypt
            
            System.out.println(new String(outputData));    
            
            System.out.println(DESCoder.toKey(key.getBytes()).getAlgorithm());    //转义算法密钥
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**  
     * BASE64解密  
     */  
    public static byte[] decryptBASE64(String key) throws Exception {   
        return (new BASE64Decoder()).decodeBuffer(key);   
    }   
  
    /**  
     * BASE64加密  
     */  
    public static String encryptBASE64(byte[] key) throws Exception {   
        return (new BASE64Encoder()).encodeBuffer(key);   
    } 
}  

其实这个来自网上，这个比较适合我用，原址：http://snowolf.javaeye.com/blog/380034


只有注册用户登录后才能发表评论。
网站导航: