Android中的加密

对称加密/解密

加入sun.misc.BASE64Decoder.jar，使用BASE64字符串解码为二进制数据或者将二进制数据编码成字符串

• 对称加密:只有一把密钥,如果密钥暴露,文件就会被暴露
  
  • des: Data Encryption Standard
  • aes: Advanced Encryption Standard
  • 特点:加密速度比较快.可以加密比较大的文件
  • 密码可以自己指定

>.Des加密/解密

public class Des {    private final static String DES = "DES";    /**     * Description 根据键值进行加密     * @param data      * @param key  加密键byte数组     * @return     * @throws Exception     */    public static String encrypt(String data, String key) throws Exception {        byte[] bt = encrypt(data.getBytes(), key.getBytes());        String strs = new BASE64Encoder().encode(bt);        return strs;    }    /**     * Description 根据键值进行解密     * @param data     * @param key  加密键byte数组     * @return     * @throws IOException     * @throws Exception     */    public static String decrypt(String data, String key) throws IOException, Exception {        if (data == null)            return null;        BASE64Decoder decoder = new BASE64Decoder();        byte[] buf = decoder.decodeBuffer(data);        byte[] bt = decrypt(buf, key.getBytes());        return new String(bt);    }    /**     * Description 根据键值进行加密     * @param data     * @param key  加密键byte数组     * @return     * @throws Exception     */    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {        // 生成一个可信任的随机数源        SecureRandom sr = new SecureRandom();        // 从原始密钥数据创建DESKeySpec对象        DESKeySpec dks = new DESKeySpec(key);        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);        SecretKey securekey = keyFactory.generateSecret(dks);        // Cipher对象实际完成加密操作        Cipher cipher = Cipher.getInstance(DES);        // 用密钥初始化Cipher对象        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);        return cipher.doFinal(data);    }    /**     * Description 根据键值进行解密     * @param data     * @param key  加密键byte数组     * @return     * @throws Exception     */    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {        // 生成一个可信任的随机数源        SecureRandom sr = new SecureRandom();        // 从原始密钥数据创建DESKeySpec对象        DESKeySpec dks = new DESKeySpec(key);        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);        SecretKey securekey = keyFactory.generateSecret(dks);        // Cipher对象实际完成解密操作        Cipher cipher = Cipher.getInstance(DES);        // 用密钥初始化Cipher对象        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);        return cipher.doFinal(data);    }}

>.Aes加密/解密

///** AES对称加密解密类 **/ public class Aes {    // /** 算法/模式/填充 **/     private static final String CipherMode = "AES/ECB/PKCS5Padding";    ///** 创建密钥 **/     private static SecretKeySpec createKey(String password) {        byte[] data = null;        if (password == null) {            password = "";        }        StringBuffer sb = new StringBuffer(32);        sb.append(password);        while (sb.length() < 32) {            sb.append("0");        }        if (sb.length() > 32) {            sb.setLength(32);        }        try {            data = sb.toString().getBytes("UTF-8");        } catch (UnsupportedEncodingException e) {            e.printStackTrace();        }        return new SecretKeySpec(data, "AES");    }    // /** 加密字节数据 **/     public static byte[] encrypt(byte[] content, String password) {        try {            SecretKeySpec key = createKey(password);            System.out.println(key);            Cipher cipher = Cipher.getInstance(CipherMode);            cipher.init(Cipher.ENCRYPT_MODE, key);            byte[] result = cipher.doFinal(content);            return result;        } catch (Exception e) {            e.printStackTrace();        }        return null;    }    ///** 加密(结果为16进制字符串) **/     public static String encrypt(String content, String password) {        byte[] data = null;        try {            data = content.getBytes("UTF-8");        } catch (Exception e) {            e.printStackTrace();        }        data = encrypt(data, password);        String result = byte2hex(data);        return result;    }    // /** 解密字节数组 **/     public static byte[] decrypt(byte[] content, String password) {        try {            SecretKeySpec key = createKey(password);            Cipher cipher = Cipher.getInstance(CipherMode);            cipher.init(Cipher.DECRYPT_MODE, key);            byte[] result = cipher.doFinal(content);            return result;        } catch (Exception e) {            e.printStackTrace();        }        return null;    }    ///** 解密16进制的字符串为字符串 **/     public static String decrypt(String content, String password) {        byte[] data = null;        try {            data = hex2byte(content);        } catch (Exception e) {            e.printStackTrace();        }        data = decrypt(data, password);        if (data == null)            return null;        String result = null;        try {            result = new String(data, "UTF-8");        } catch (UnsupportedEncodingException e) {            e.printStackTrace();        }        return result;    }    // /** 字节数组转成16进制字符串 **/     public static String byte2hex(byte[] b) { // 一个字节的数，         StringBuffer sb = new StringBuffer(b.length * 2);        String tmp = "";        for (int n = 0; n < b.length; n++) {            // 整数转成十六进制表示             tmp = (Integer.toHexString(b[n] & 0XFF));            if (tmp.length() == 1) {                sb.append("0");            }            sb.append(tmp);        }        return sb.toString().toUpperCase(); // 转成大写     }    // /** 将hex字符串转换成字节数组 **/     private static byte[] hex2byte(String inputString) {        if (inputString == null || inputString.length() < 2) {            return new byte[0];        }        inputString = inputString.toLowerCase();        int l = inputString.length() / 2;        byte[] result = new byte[l];        for (int i = 0; i < l; ++i) {            String tmp = inputString.substring(2 * i, 2 * i + 2);            result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);        }        return result;    }}

非对称加密/解密(Rsa)

• 非对称加密:有两把钥匙(密钥对),公钥和私钥,公钥的话给别人.私钥自己保存;
  
  • RSA
  • 特点:加密速度比慢一些,但是安全系数比较高
  • 秘钥对的话需要程序生成.不能我们自己定义
  • 加密/解密:公钥加密–>私钥解密
  • 加密/解密:私钥加密–>公钥解密

public class RSACrypt {    /**     * 文件读取缓冲区大小     */    private static final int CACHE_SIZE = 1024;    /**     * <p>     * BASE64字符串解码为二进制数据     * </p>     *      * @param base64     * @return     * @throws Exception     */    public static byte[] decode(String base64) throws Exception {        return new BASE64Decoder().decodeBuffer(base64);    }    /**     * <p>     * 二进制数据编码为BASE64字符串     * </p>     *      * @param bytes     * @return     * @throws Exception     */    public static String encode(byte[] bytes) throws Exception {        return new BASE64Encoder().encode(bytes);    }    /**     * 加密算法RSA     */    // public static final String KEY_ALGORITHM = "RSA";    public static final String KEY_ALGORITHM = "RSA";    /**     * 签名算法     */    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";    /**     * 获取公钥的key     */    private static final String PUBLIC_KEY = "RSAPublicKey";    /**     * 获取私钥的key     */    private static final String PRIVATE_KEY = "RSAPrivateKey";    /**     * RSA最大加密明文大小     */    private static final int MAX_ENCRYPT_BLOCK = 117;    /**     * RSA最大解密密文大小     */    private static final int MAX_DECRYPT_BLOCK = 128;    /**     * <p>     * 生成密钥对(公钥和私钥)     * </p>     *      * @return     * @throws Exception     */    public static Map<String, Object> genKeyPair() throws Exception {        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);        keyPairGen.initialize(1024);        KeyPair keyPair = keyPairGen.generateKeyPair();        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();        Map<String, Object> keyMap = new HashMap<String, Object>(2);        keyMap.put(PUBLIC_KEY, publicKey);        keyMap.put(PRIVATE_KEY, privateKey);        return keyMap;    }    /**     * <p>     * 生成密钥对(公钥和私钥)     * </p>     *      * @return     * @throws Exception     */    public static Map<String, Object> genKeyPair(String seed) throws Exception {        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);        keyPairGen.initialize(1024);        //生成一个可信任的随机数源        // SecureRandom secrand = new SecureRandom();        // secrand.setSeed(seed.getBytes()); // 初始化随机产生器        // keyPairGen.initialize(1024, secrand);        KeyPair keyPair = keyPairGen.generateKeyPair();        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();        Map<String, Object> keyMap = new HashMap<String, Object>(2);        keyMap.put(PUBLIC_KEY, publicKey);        keyMap.put(PRIVATE_KEY, privateKey);        return keyMap;    }    /**     * <p>     * 用私钥对信息生成数字签名     * </p>     *      * @param data     *            已加密数据     * @param privateKey     *            私钥(BASE64编码)     *      * @return     * @throws Exception     */    public static String sign(byte[] data, String privateKey) throws Exception {        byte[] keyBytes = decode(privateKey);        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);        signature.initSign(privateK);        signature.update(data);        return encode(signature.sign());    }    /**     * <p>     * 校验数字签名     * </p>     *      * @param data     *            已加密数据     * @param publicKey     *            公钥(BASE64编码)     * @param sign     *            数字签名     *      * @return     * @throws Exception     *      */    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {        byte[] keyBytes = decode(publicKey);        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        PublicKey publicK = keyFactory.generatePublic(keySpec);        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);        signature.initVerify(publicK);        signature.update(data);        return signature.verify(decode(sign));    }    /**     * <P>     * 私钥解密     * </p>     *      * @param encryptedData     *            已加密数据     * @param privateKey     *            私钥(BASE64编码)     * @return     * @throws Exception     */    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {        byte[] keyBytes = decode(privateKey);        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);//       Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");        cipher.init(Cipher.DECRYPT_MODE, privateK);        int inputLen = encryptedData.length;        ByteArrayOutputStream out = new ByteArrayOutputStream();        int offSet = 0;        byte[] cache;        int i = 0;        // 对数据分段解密        while (inputLen - offSet > 0) {            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);            } else {                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);            }            out.write(cache, 0, cache.length);            i++;            offSet = i * MAX_DECRYPT_BLOCK;        }        byte[] decryptedData = out.toByteArray();        out.close();        return decryptedData;    }    /**     * <p>     * 公钥解密     * </p>     *      * @param encryptedData     *            已加密数据     * @param publicKey     *            公钥(BASE64编码)     * @return     * @throws Exception     */    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {        byte[] keyBytes = decode(publicKey);        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key publicK = keyFactory.generatePublic(x509KeySpec);        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");        cipher.init(Cipher.DECRYPT_MODE, publicK);        int inputLen = encryptedData.length;        ByteArrayOutputStream out = new ByteArrayOutputStream();        int offSet = 0;        byte[] cache;        int i = 0;        // 对数据分段解密        while (inputLen - offSet > 0) {            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);            } else {                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);            }            out.write(cache, 0, cache.length);            i++;            offSet = i * MAX_DECRYPT_BLOCK;        }        byte[] decryptedData = out.toByteArray();        out.close();        return decryptedData;    }    /**     * <p>     * 公钥加密     * </p>     *      * @param data     *            源数据     * @param publicKey     *            公钥(BASE64编码)     * @return     * @throws Exception     */    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {        byte[] keyBytes = decode(publicKey);        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key publicK = keyFactory.generatePublic(x509KeySpec);        // 对数据加密        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");        cipher.init(Cipher.ENCRYPT_MODE, publicK);        int inputLen = data.length;        ByteArrayOutputStream out = new ByteArrayOutputStream();        int offSet = 0;        byte[] cache;        int i = 0;        // 对数据分段加密        while (inputLen - offSet > 0) {            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);            } else {                cache = cipher.doFinal(data, offSet, inputLen - offSet);            }            out.write(cache, 0, cache.length);            i++;            offSet = i * MAX_ENCRYPT_BLOCK;        }        byte[] encryptedData = out.toByteArray();        out.close();        return encryptedData;    }    /**     * <p>     * 私钥加密     * </p>     *      * @param data     *            源数据     * @param privateKey     *            私钥(BASE64编码)     * @return     * @throws Exception     */    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {        byte[] keyBytes = decode(privateKey);        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");        cipher.init(Cipher.ENCRYPT_MODE, privateK);        int inputLen = data.length;        ByteArrayOutputStream out = new ByteArrayOutputStream();        int offSet = 0;        byte[] cache;        int i = 0;        // 对数据分段加密        while (inputLen - offSet > 0) {            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);            } else {                cache = cipher.doFinal(data, offSet, inputLen - offSet);            }            out.write(cache, 0, cache.length);            i++;            offSet = i * MAX_ENCRYPT_BLOCK;        }        byte[] encryptedData = out.toByteArray();        out.close();        return encryptedData;    }    /**     * <p>     * 获取私钥     * </p>     *      * @param keyMap     *            密钥对     * @return     * @throws Exception     */    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {        Key key = (Key) keyMap.get(PRIVATE_KEY);        return encode(key.getEncoded());    }    /**     * <p>     * 获取公钥     * </p>     *      * @param keyMap     *            密钥对     * @return     * @throws Exception     */    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {        Key key = (Key) keyMap.get(PUBLIC_KEY);        return encode(key.getEncoded());    }}