MD5、DES、RSA消息加密解密

   最近做的一个项目中用到这几种加密解密算法，简单总结下用法。
一 MD5、DES、RSA的基本概念？
      相信大家多多少少都接触过一些加密解密算法，MD5可以说是最常用的一种了，MD5是直接对要加密信息进行加密的消息摘要算法，DES是一种对称加密算法，RSA则是一种非对称加密算法。

     所谓对称加密是一种将原始数据（需加密消息）和加密密钥key一起经过特殊加密算法处理,在解密时使用同一密钥（加密时使用的加密密钥key）与加过密的数据一起经过相同算法的逆算法对密文进行解密。

     非对称加密是借助匹配的一对密钥（公钥publicKey 和私钥privateKey），加密时借助公钥和原始数据（需加密消息）一起经过特殊加密算法处理，解密时采用私钥和加过密的数据进过逆算法对密文进行解密；或者加密时使用私钥进行加密，解密时使用公钥进行解密。

1、java(jdk1.6)中java.security.MessageDigest抽象类为应用程序提供信息摘要算法的功能,用法也非常简单。
  

  MessageDigest md = MessageDigest.getInstance("MD5"); // 初始化
	
  byte b_data [] = dataString.getByte();  // 加密前先将需加密数据（字符串dataString）转成byte[]
        
  byte md5_result [] = md.digest(b_data); // 加密返回摘要信息

2、DES算法，首先需要生成一个密钥key，这里采用随机数生成，然后根据这个密钥进行加密解密操作。

SecureRandom sr = new SecureRandom(); // DES算法要求有一个可信任的随机数源
        KeyGenerator desKg = KeyGenerator.getInstance("DES"); // 为DES算法生成一个KeyGenerator对象
        desKg.init(sr);  

        SecretKey key = desKg.generateKey(); //获取密钥对象

        byte[]  rawKeyData = key.getEncoded(); // 生成DES密钥

/**
     * 利用DES算法加密二进制数据
     * rawKeyData  密钥key | rawOrignData 需加密数据 
     * @param rawKeyData byte[]
     * @param byOrignData byte[]
     * @return byte[]
     */
    public static byte[] desEncrypt(byte[] rawKeyData,byte[] rawOrignData) throws Exception
    {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(rawKeyData);

        // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance("DES");

        // 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, key, sr);

        // 现在，获取数据并加密
        byte encryptedData[] = cipher.doFinal(rawOrignData);

        // 返回加密后的数据
        return encryptedData;
    }

    /**
     * 利用DES算法解密二进制数据
     * rawKeyData 密钥key | rawCryptograph 需解密数据
     * @param rawKeyData byte[]
     * @param rawCryptograph byte[]
     * @return byte[]
     */
    public static byte[] desDecrypt(byte[] rawKeyData,byte[] rawCryptograph) throws Exception
    {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密匙数据创建一个DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(rawKeyData);

        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");

        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, key, sr);

        // 正式执行解密操作
        return cipher.doFinal(rawCryptograph);
    }

3、RSA算法，首先需要生成密钥对（公钥publicKey、私钥privateKey），这里采用随机数产生，然后根据密钥对进行加密解密操作。

// 为RSA算法，这里借助了jar包 bcprov-jdk14-145.jar 用来生成一个KeyPairGenerator对象
            KeyPairGenerator  kpg = KeyPairGenerator.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
           
            //指定密钥的长度，初始化密钥对生成器 （这里假设密钥长度为1024）
            SecureRandom ran = new SecureRandom();
            kpg.initialize(1024, ran);

            KeyPair keyPair = kpg.genKeyPair(); //生成密钥对

            //获取公钥
            RSAPublicKey pbkey = (RSAPublicKey) keyPair.getPublic();
            BigInteger PublicExponent = pbkey.getPublicExponent(); // 从RSA密钥对中获取公有指数
            
            //或者获取私钥
            RSAPrivateKey prkey = (RSAPrivateKey)keyPair.getPrivate();
            BigInteger PrivateExponent = prkey.getPrivateExponent(); //从RSA密钥对中获取私有指数

            BigInteger Modulus = pbkey.getModulus(); // RSA 密钥对中用到的一个公共系数

            //（RSA公钥对象是有PublicExponent + Modulus 生成的，私钥对象是有rivateExponent + Modulus生成的）

/**
     * 根据系数和指数生成公钥
     * @param Modulus BigInteger
     * @param PublicExponent BigInteger
     * @return void
     */
    private static RSAPublicKey generateRSAPublicKey(BigInteger Modulus, BigInteger PublicExponent) throws Exception {

        KeyFactory keyFac = null;

        try {

            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

        } catch (NoSuchAlgorithmException ex) {

            throw new Exception(ex.getMessage());

        }

        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(Modulus, PublicExponent);

        try {

            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);

        } catch (InvalidKeySpecException ex) {

            throw new Exception(ex.getMessage());

        }
    }

    /**
     * 根据系数和指数生成私钥
     * @param Modulus BigInteger
     * @param PrivateExponent BigInteger
     * @return void
     */
    private static RSAPrivateKey generateRSAPrivateKey(BigInteger Modulus, BigInteger PrivateExponent) throws Exception {

        KeyFactory keyFac = null;

        try {
            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

        } catch (NoSuchAlgorithmException ex) {

            throw new Exception(ex.getMessage());

        }

        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(Modulus, PrivateExponent);

        try {

            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);

        } catch (InvalidKeySpecException ex) {

            throw new Exception(ex.getMessage());
        }
    }


/**   
  * RSA加密
  * Encrypt method  
  *   
  * @return byte[]   
  */   
  protected byte[] encrypt(RSAPublicKey publicKey, byte[] data) {   
	  if (publicKey != null) {   
		  try {   
			  Cipher cipher = Cipher.getInstance("RSA",  new org.bouncycastle.jce.provider.BouncyCastleProvider());   
			  cipher.init(Cipher.ENCRYPT_MODE, publicKey);   
			  return cipher.doFinal(data);   
		  } catch (Exception e) {   
			  e.printStackTrace();   
		  }   
	  }   
	  return null;   
  }   
    
/**   
  * RSA解密
  * decrypt method   
  *   
  * @return byte[]   
  */   
  protected byte[] decrypt(RSAPrivateKey privateKey, byte[] raw) {   
	  if (privateKey != null) {   
	       try {   
		      Cipher cipher = Cipher.getInstance("RSA",  new org.bouncycastle.jce.provider.BouncyCastleProvider());   
		      cipher.init(Cipher.DECRYPT_MODE, privateKey);   
		      return cipher.doFinal(raw);   
	       } catch (Exception e) {   
		      e.printStackTrace();   
	       }   
	  }   
	    
	  return null;   
  }