Android应用开发之数据加密浅析

约定不等于承诺〃 2022-06-17 03:25 261阅读 0赞

第一次很认真的写博客，第一次使用CSDN-markdown的编辑工具，语法格式都不是很懂，先练习的写一下，用于自己的学习记录。一周前刚刚换了一家公司，公司工作环境和气氛都比较好。希望自己能够尽快的融入集体中。进入公司的第一周，就是配置环境，拿到我会参与的项目，调试了项目的环境，到能够正常打包，运行，速度还是比较快的，还受到了夸奖。哈哈哈哈，不再扯了。说说我接到的第一个任务吧，领导让我看下加密，分析他们的优缺点。

## 介绍 ##

在Android开发中那面会遇到把一些内容进行加密保存的本地文件，或者在与服务器进行传输数据的时候需要进行加密，以防止数据在传输过程中被截获，导致数据泄密。这里我所了解的解密有MD5 ，SHA， DES， AES RSA。其中MD5 和SHA是不可逆的，其他的均可逆。

## 基本作用 ##

密码学的三大作用：加密（ Encryption）、认证（Authentication），鉴定（Identification）  
加密：防止坏人获取你的数据。  
认证：防止坏人修改了你的数据而你却并没有发现。  
鉴权：防止坏人假冒你的身份。  
明文、密文、密钥、对称加密算法、非对称加密算法，这些基本概念和加密算法原理就不展开叙述了。

## 分类 ##

对称加密： RSA  
非对称加密：DES，AES  
不可逆加密 ：MD5，SHA

## 完整示例 ##

### 对称加密-RSA ###

RSA是非对称加密的主要一种，非对称加密算法需要两个秘钥，公开密钥（publicKey），私有密钥（privateKey），公开秘钥和私有秘钥是一堆，使用公钥对数据进行加密，只有对应的私钥才能解密，反之亦然。RSA加密的秘钥长度可以由我们自己指定，512~2018位，当然秘钥长度越长，安全度越高，RSA的安全性依赖于大数分解，小于1024位的N已经被证明是不安全的，而且由于RSA算法进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，这是RSA最大的缺陷，因此通常只能用于加密少量数据或者加密密钥，但RSA仍然不失为一种高强度的算法。

#### 代码 ####

public class RSA {
        
        public static final String KEY_ALGORITHM = "RSA";
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        private static final String PUBLIC_KEY = "RSAPublicKey";
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        public static byte[] decryptBASE64(String key) throws Exception {
            return Base64.decode(key, Base64.DEFAULT);
        }
    
        public static String encryptBASE64(byte[] key) throws Exception {
            return Base64.encodeToString(key, Base64.DEFAULT);
        }
    
        /**
         * 用私钥对信息生成数字签名
         *
         * @param data       加密数据
         * @param privateKey 私钥
         * @return
         * @throws Exception
         */
        public static String sign(byte[] data, String privateKey) throws Exception {
            // 解密由base64编码的私钥
            byte[] keyBytes = decryptBASE64(privateKey);
    
            // 构造PKCS8EncodedKeySpec对象
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    
            // KEY_ALGORITHM 指定的加密算法
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 取私钥匙对象
            PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
    
            // 用私钥对信息生成数字签名
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(priKey);
            signature.update(data);
    
            return encryptBASE64(signature.sign());
        }
    
        /**
         * 校验数字签名
         *
         * @param data      加密数据
         * @param publicKey 公钥
         * @param sign      数字签名
         * @return 校验成功返回true 失败返回false
         * @throws Exception
         */
        public static boolean verify(byte[] data, String publicKey, String sign)
                throws Exception {
    
            // 解密由base64编码的公钥
            byte[] keyBytes = decryptBASE64(publicKey);
    
            // 构造X509EncodedKeySpec对象
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    
            // KEY_ALGORITHM 指定的加密算法
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 取公钥匙对象
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
    
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(pubKey);
            signature.update(data);
    
            // 验证签名是否正常
            return signature.verify(decryptBASE64(sign));
        }
    
        /**
         * 解密<br>
         * 用私钥解密
         *
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] data, String key)
                throws Exception {
            // 对密钥解密
            byte[] keyBytes = decryptBASE64(key);
    
            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    
            // 对数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
    
            return cipher.doFinal(data);
        }
    
        /**
         * 解密<br>
         * 用公钥解密
         *
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] data, String key)
                throws Exception {
            // 对密钥解密
            byte[] keyBytes = decryptBASE64(key);
    
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicKey = keyFactory.generatePublic(x509KeySpec);
    
            // 对数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
    
            return cipher.doFinal(data);
        }
    
        /**
         * 加密<br>
         * 用公钥加密
         *
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String key)
                throws Exception {
            // 对公钥解密
            byte[] keyBytes = decryptBASE64(key);
    
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicKey = keyFactory.generatePublic(x509KeySpec);
    
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    
            return cipher.doFinal(data);
        }
    
        /**
         * 加密<br>
         * 用私钥加密
         *
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String key)
                throws Exception {
            // 对密钥解密
            byte[] keyBytes = decryptBASE64(key);
    
            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    
            return cipher.doFinal(data);
        }
    
        /**
         * 取得私钥
         *
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
    
            return encryptBASE64(key.getEncoded());
        }
    
        /**
         * 取得公钥
         *
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
    
            return encryptBASE64(key.getEncoded());
        }
    
        /**
         * 初始化密钥
         *
         * @return
         * @throws Exception
         */
        public static Map<String, Object> initKey() 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;
        }
    }

### 对称加密 ###

对于对称加密码我们常用的就是DES和AES，在对称加密算法中，只有一个秘钥，可以自己指定，很多情况下我们也会随机生成再进行处理，此时会用到随机生成器SecureRandom类，此处不做详细介绍，发信方和接收方使用相同的秘钥进行加解密，存在的安全风险要比非对称加密要高。因为秘钥一旦泄漏或者被盗取，数据就会泄露。而AES（Advanced Encryption Standard）是比DES更高级的一种对称加密，所以我们尽量使用AES加密，根据我们数据的保密成都来定。

#### 代码-AES ####

public class AES {
        
        public static final String ALGORITHM = "AES";
    
        public static byte[] decryptBASE64(String key) throws Exception {
            return Base64.decode(key, Base64.DEFAULT);
        }
    
        public static String encryptBASE64(byte[] key) throws Exception {
            return Base64.encodeToString(key, Base64.DEFAULT);
        }
    
        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());
        }
    }

#### 代码-DES ####

public class DES {
        
        public static final String ALGORITHM = "DES";
    
        public static byte[] decryptBASE64(String key) throws Exception {
            return Base64.decode(key, Base64.DEFAULT);
        }
    
        public static String encryptBASE64(byte[] key) throws Exception {
            return Base64.encodeToString(key, Base64.DEFAULT);
        }
    
        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());
        }
    
    }

### 不可逆加密-MD5 ###

不可逆的加密一般用于用户密码的校验，文件的完整性的校验。
    MD5算法的特点：
    1、压缩性：任意长度的数据，算出的MD5值长度都是固定的。
    3、抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
    5、强抗碰撞：想找到两个不同的数据，使它们具有相同的MD5值，是非常困难的。

#### 代码-MD5 ####

public String md5(String content){
            byte[] hash ;
            try {
                hash  = MessageDigest.getInstance("MD5").digest(content.getBytes("UTF-8"));
                StringBuilder hex = new StringBuilder(hash.length*2);
                //加密结果转成16进制的字符串
                for (byte b:hash){
                    if ((b&0xff)<0x10){
                        hex.append("0");
                    }
                    hex.append(Integer.toHexString((b&0xff)));
                }
                return hex.toString();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
    
    
            return null;
        }
    
       // 但有点需要注意的是，md5加密文件可能要耗时很久，所以在Android平台上开发最好是异步进行。我demo例子加密了一个188M大小的视频大概用了2秒
        public String md5File(File file ){
    
            int bufferSize = 1024;
            FileInputStream fis = null;
            DigestInputStream dis = null;
            try {
                MessageDigest messageDigest = MessageDigest.getInstance("MD5");
                fis = new FileInputStream(file);
                dis = new DigestInputStream(fis,messageDigest);
                byte[] buffer = new byte[bufferSize];
                //DigestInputStream实际上在流处理文件时就在内部就进行了一定的处理
                while (dis.read(buffer)>0){
                    //通过DigestInputStream对象得到一个最终的MessageDigest对象。
                    messageDigest = dis.getMessageDigest();
                    byte [] array = messageDigest.digest();
                    //同样把字节数组转化成字符串
                    StringBuilder hex = new StringBuilder(array.length * 2);
                    for (byte b : array) {
                        if ((b & 0xFF) < 0x10){
                            hex.append("0");
                        }
                        hex.append(Integer.toHexString(b & 0xFF));
                    }
                    return hex.toString();
    
                }
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
    
            return null;
        }

#### 代码-SHA ####

public class SHA {
        
    
        /**
         * @param data to be encrypted
         * @param shaN encrypt method,SHA-1,SHA-224,SHA-256,SHA-384,SHA-512
         * @return 已加密的数据
         * @throws Exception
         */
        public static byte[] encryptSHA(byte[] data, String shaN) throws Exception {
            MessageDigest sha = MessageDigest.getInstance(shaN);
            sha.update(data);
            return sha.digest();
        }
    
        public static String encryptSHAToString(byte[] data,String shaN) throws Exception {
            byte[] bytes = encryptSHA(data,shaN);
            StringBuffer sb = new StringBuffer();
            for (byte b: bytes){
                sb.append(String.format("%2x",b));
            }
            return sb.toString();
        }
    
    }

## 总结 ##

总体来说我认为相对安全的算法会比较复杂，速度会比较慢 有些加密也会对数据的长度会限制。如果是做一些校验我们可以使用MD5进行加密，比如账户密码校验，在安全性方面RSA较AES和DES安全，RSA的弊端是他可以加密的数据长度是有限的，那么当数据较大时我们可以使用DES或者AES进行加密，然后再用RSA对AES的加密秘钥进行加密两者进行结合。

## 引用 ##

> 几条原则：  
> 1、不要自己设计加密算法和协议，使用业界标准的算法。  
> 2、对称加密算法不要使用ECB模式，不建议使用DES算法。  
> 3、要选择合适长度的密钥。  
> 4、要确保随机数生成器的种子具有足够的信息熵。  
> 5、不要使用没有消息认证的加密算法加密消息，无法防重放。  
> 6、当多个字符串拼接后做hash，要非常当心。  
> 7、当给算法加yan盐取值时不要太短，不要重复。  
> 8、使用初始化向量时IV时，IV为常量的CBC，CFB，GCM等和ECB一样可以重放，即采用上一个消息的最后一块密文作为下一个消息的IV，是不安全的。  
> 9、密钥应遵循的原则  
> （1）密钥不能为常量，应随机，定期更换，如果加密数据时使用的密钥为常量，则相同明文加密会得到相同的密文，很难防止字典攻击。  
> （2）开发同学要防范密钥硬编码的毛病。

#### 参考： ####

[http://www.cnblogs.com/alisecurity/p/5312083.html][http_www.cnblogs.com_alisecurity_p_5312083.html]

[http_www.cnblogs.com_alisecurity_p_5312083.html]: http://www.cnblogs.com/alisecurity/p/5312083.html