android基本上每个项目可能都需要和后台进行交互通信，期间为了保证数据的安全性，我们都进行了数据加密，今天我们就来了解学习下aes数据加密。

aes数据加密是什么？

高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

加密工具类使用到的常量介绍

private final static String HEX = "0123456789ABCDEF";
private  static final String CBC_PKCS5_PADDING "AES/CBC/PKCS5Padding";//AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
private  static final String AES = "AES";//AES 加密
private  static final String  SHA1PRNG="SHA1PRNG";//// SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

加密工具类

import android.text.TextUtils;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class AESUtils {
private static final String SHA1PRNG = "SHA1PRNG"; // SHA1PRNG 强随机 
种子算法, 要区别4.2以上版本的调用方法
 private static final String IV = "ABCDEFGH01234567";
  private static final String AES = "AES"; //AES 加密

public static String encrypt(String key, String cleartext) {
    if (TextUtils.isEmpty(cleartext)) {
        return cleartext;
    }
    try {
        byte[] result = encrypt(key, cleartext.getBytes());
        return parseByte2HexStr(result);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 加密
 */
public static byte[] encrypt(String key, byte[] clear) throws Exception {
    byte[] raw = getRawKey(key.getBytes());
    SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
    Cipher cipher = Cipher.getInstance("AES");
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
    byte[] encrypted = cipher.doFinal(clear);
    return encrypted;
}

/**
 * 解密
 */
public static String decrypt(String key, String encrypted) {
    if (TextUtils.isEmpty(encrypted)) {
        return encrypted;
    }
    try {
        byte[] enc = parseHexStr2Byte(encrypted);
        byte[] result = decrypt(key, enc);
        return new String(result);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 解密
 */
public static byte[] decrypt(String key, byte[] encrypted) throws Exception {
    byte[] raw = getRawKey(key.getBytes());
    SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
    Cipher cipher = Cipher.getInstance(AES);
    cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
    byte[] decrypted = cipher.doFinal(encrypted);
    return decrypted;
}

/**
 * 生成随机数，可以当做动态的密钥
 * 加密和解密的密钥必须一致，不然将不能解密
 */
public static String generateKey() {
    try {
        SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
        byte[] key = new byte[20];
        secureRandom.nextBytes(key);
        return toHex(key);
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 对密钥进行处理
 */
public static byte[] getRawKey(byte[] seed) throws Exception {
    byte[] rawKey = rawKey = InsecureSHA1PRNGKeyDerivator.deriveInsecureKey(seed, 32);
    return rawKey;
}

/**
 * 二进制转字符
 */
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 static void appendHex(StringBuffer sb, byte b) {
    sb.append(IV.charAt((b >> 4) & 0x0f)).append(IV.charAt(b & 0x0f));
}

/**
 * 将二进制转换成16进制
 *
 * @param buf
 * @return
 */
public static String parseByte2HexStr(byte buf[]) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < buf.length; i++) {
        String hex = Integer.toHexString(buf[i] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        sb.append(hex.toUpperCase());
    }
    return sb.toString();
}

/**
 * 将16进制转换为二进制
 *
 * @param hexStr
 * @return
 */
public static byte[] parseHexStr2Byte(String hexStr) {
    if (hexStr.length() < 1) {
        return null;
    }
    byte[] result = new byte[hexStr.length() / 2];
    for (int i = 0; i < hexStr.length() / 2; i++) {
        int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
        int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
                16);
        result[i] = (byte) (high * 16 + low);
    }
    return result;
}
}