DES、AES加密

加密是通过加密算法和加密密钥将明文转变为密文的过程，解密是其逆过程。加密算法有很多种，一般可以分为对称加密（如DES、AES等）、非对称加密（如RSA等）和单向加密（如MD5等）3类算法。

1）在对称加密算法中，双方使用的密钥相同，要求解密方事先必须知道加密密钥。这类加密算法技术较为成熟，加密效率高。

2）在非对称加密算法中，收发双方使用不同的密钥，发方使用公开密钥对消息进行加密，收发使用私有密钥机型解密，保密性更高，但效率更低。

3）单向加密算法在加密过程中不需要使用密钥，输入明文后由算法直接加密成密文，密文无法解密，只有重新输入密文，并经过同样的加密算法处理，得到形同的密文并被系统重新识别后，才能真正的解密，这种算法非常复杂，通常只在数据量有限的情形下使用，如广泛应用在计算机系统中的口令加密等。

下面给大家介绍DES、AES、MD5三种算法。三种算法具体的加解密过程设计的内容较多，这里只做一个简要的介绍。

1）DES是数据加密标准（Data Encryption Standard）的简称，他是第一代公开的、完全说明细节的商用密码算法。它在保护金融数据的安全，如自动取款机中，使用较多。DES算法经过16论迭代，使用56比特长度密钥加密64比特长度（分组长度）的明文获得64比特的密文。

2）AES是高级加密标准（Advanced Encryption Standard）的简称，用于替代原先的DES，保护敏感信息。AES算法的分组长度为128比特，其密钥长度分别为128比特，192比特，256比特。

3）MD5全称是Message-digest Algorithm5（信息摘要算法），用于确保信息传输完整的一致。MD5用的是散列函数（Hash函数），其典型应用是对一段信息产生信息摘要，从而事先数字签名，登录口令的认证，为文档生成“数字指纹”等。MD5算法的基本思想是以512位分组来处理输入的信息，且每一分组又被划分位16个32分组，经过一系列的处理后算法输出由4个32位分组组成，将这4个32位分组级联后将生产一个128位的散列值。

一、DES加密和解密

Android中实现DES加密和解密的核心代码如下：

import android.util.Base64;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * Created by 宫智耀 on 2016/10/13.
 */
public class DES {
    //初始化向量，随意填写
    private static byte[]iv={1,2,3,4,5,6,7,8};


    /**
     * 
     * @param encryptString 明文
     * @param encryptKey 密钥
     * @return 加密后的密文
     */
    public static String encryptDES(String encryptString,String encryptKey){
        
        try {
            //实例化IvParameterSpec对象，使用指定的初始化向量
            IvParameterSpec zeroIv=new IvParameterSpec(iv);
            //实例化SecretKeySpec，根据传入的密钥获得字节数组来构造SecretKeySpec
            SecretKeySpec key =new SecretKeySpec(encryptKey.getBytes(),"DES");
            //创建密码器
            Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
            //用密钥初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE,key,zeroIv);
            //执行加密操作
            byte[]encryptedData=cipher.doFinal(encryptString.getBytes());
            return Base64.encodeToString(encryptedData,0);
            
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    return null;
    }


    /**
     * 解密的过程与加密的过程大致相同
     * @param decryptString 密文
     * @param decryptKey 密钥
     * @return  返回明文
     */
    
    public static String decryptDES(String decryptString,String decryptKey){
       
        try {
            //先使用Base64解密
            byte[]byteMi=Base64.decode(decryptString,0);
            //实例化IvParameterSpec对象使用指定的初始化向量
            IvParameterSpec zeroIv=new IvParameterSpec(iv);
            //实例化SecretKeySpec，根据传入的密钥获得字节数组来构造SecretKeySpec,
            SecretKeySpec key=new SecretKeySpec(decryptKey.getBytes(),"DES");
            //创建密码器
            Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
            //用密钥初始化Cipher对象,上面是加密，这是解密模式
            cipher.init(Cipher.DECRYPT_MODE,key,zeroIv);
            //获取解密后的数据
            byte [] decryptedData=cipher.doFinal(byteMi);
            return new String(decryptedData);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }
}

如何调用DES加密和解密的方法在这里就不在赘述了。

二、AES解密和解密

Android中AES加密和解密的核心代码如下：

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 * Created by 宫智耀 on 2016/10/13.
 */
public class AES {

    /**
     * AES 加密
     *
     * @param seed      密钥
     * @param cleartext 明文
     * @return 密文
     */
    public static String encrypt(String seed, String cleartext) {
        //对密钥进行加密
        byte[] rawkey = getRawKey(seed.getBytes());
        //加密数据
        byte[] result = encrypt(rawkey, cleartext.getBytes());
        //将十进制数转换为十六进制数
        return toHex(result);
    }


    /**
     * AES 解密
     *
     * @param seed      密钥
     * @param encrypted 密文
     * @return 明文
     */
    public static String decrypt(String seed, String encrypted) {
        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] enc = toByte(encrypted);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
    }


    private static byte[] getRawKey(byte[] seed) {

        try {
            //获取密钥生成器
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
            sr.setSeed(seed);
            //生成位的AES密码生成器
            kgen.init(128, sr);
            //生成密钥
            SecretKey skey = kgen.generateKey();
            //编码格式
            byte[] raw = skey.getEncoded();
            return raw;

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;

    }


    private static byte[] encrypt(byte[] raw, byte[] clear) {

        try {
            //生成一系列扩展密钥，并放入一个数组中
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            //使用ENCRYPT_MODE模式，用skeySpec密码组，生成AES加密方法
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            //得到加密数据
            byte[] encrypted = cipher.doFinal(clear);
            return encrypted;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }

    private static byte[] decrypt(byte[] raw, byte[] encrypted) {

        try {
            //生成一系列扩展密钥，并放入一个数组中
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = null;
            cipher = Cipher.getInstance("AES");
            //使用DECRYPT_MODE模式，用skeySpec密码组，生成AES解密方法
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            //得到加密数据
            byte[] decrypted = cipher.doFinal(encrypted);
            return decrypted;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
        return null;

    }


    //将十进制数转为十六进制
    public static String toHex(String txt) {
        return toHex(txt.getBytes());
    }

    //将十六进制字符串转换位十进制字符串
    public static String fromHex(String hex) {
        return new String(toByte(hex));
    }

    //将十六进制字符串转为十进制字节数组
    public static byte[] toByte(String hexString) {
        int len = hexString.length() / 2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++) {
            result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).byteValue();
        }
        return result;
    }

    //将十进制字节数组转换为十六进制
    public static String toHex(byte[]buf){
        if(buf==null){
            return "";
        }
        StringBuffer result=new StringBuffer(2*buf.length);
        for(int i=0;i<buf.length;i++){
            appendHex(result,buf[i]);
        }
        return result.toString();
    }

    
    private final static String HEX="0123456789ABCDEF";
    
    private static void appendHex(StringBuffer sb,byte b){
        sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
    }

}

三、MD5加密

关于MD5的加密算法，在前面我已经给大家介绍过，地址是http://blog.csdn.net/gongzhiyao3739124/article/details/51729085
，这里就不在重述。

好了，这就是DES，AES，和MD5三种加密算法的简单介绍和使用。