Android 加密算法

短命女 2022-12-22 09:46 340阅读 0赞

# **1.不可逆的算法** #

主要为MD5和SHA-1算法。(二者都不属于加密只能算作一种算法)，如Android的App签名也是用的这两种算法。

相同点：都是使用目前比较广泛的散列(Hash)函数，就是把任意长度的输入，变换成固定长度的输出，该输出就是散列值。计算的时候所有的数据都参与了运算，其中任何一个数据变化了都会导致计算出来的Hash值完全不同。（理论上来讲产生的密文都有可能产生碰撞）

不同点：MD5输出是128位的，SHA-1输出是160位的，MD5比SHA1运行速度快，SHA1比MD5强度高。MD5一般用于文件的校验，SHA-1主要使用于数字签名标准。

###   **既然md5算法不可逆，那么加密得到一串字符串有什么用？** ###

可以当做密码验证，为了保证密码不在cmd5网站上破译，最好加盐及乱序，也可以只取一半md5的长度。md5是不可逆算法，**只要保证算法不变，就能和数据库中的md5相匹配**。关于MD5加密！有什么用途呢？比如一个password认证，加密后存入数据库和不加密有什么区别？**首先因为是不可逆的**，**所以在数据库里面看到的密码是无用的，你不是检验用户的密码，而是检验用户输入的密码经md5加密以后和数据库内的是否相符 这样就能做到你不希望你的邮件服务器的管理员知道你的信用卡密码吧！**

**　MD5使用：**

public static String digest(String content){
        StringBuilder builder = new StringBuilder();
        try {
            MessageDigest msgDitest = MessageDigest.getInstance("MD5");
            msgDitest.update(content.getBytes());
            byte[] digests = msgDitest.digest();
            //将每个字节转为16进制
            for (int i=0;i<digests.length;i++){
                // md5具有不可逆性，也可用来作为密码加密，并且通常情况下为了让加密过程变得不可预测，我们会进行加盐操作
                builder.append(Integer.toHexString(digests[i] & 0xff +8));//+8为加盐操作
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return  builder.toString();
    }

**SHA-1使用：**

public static String sha1Digest(String content){
       StringBuilder builder = new StringBuilder();
       try {
           MessageDigest msgDitest = MessageDigest.getInstance("SHA-1");
           msgDitest.update(content.getBytes());
           byte[] digests = msgDitest.digest();
           //将每个字节转为16进制
           for (int i=0;i<digests.length;i++){
               // TODO: 2019/11/10 再了解一下
               builder.append(Integer.toHexString(digests[i] & 0xff +8));//+8为加盐操作
           }
       } catch (NoSuchAlgorithmException e) {
           e.printStackTrace();
       }
       return  builder.toString();
    }

# **2.可逆算法** #

其中可逆算法按照密钥的数量和加密规则又分为对称加密和非对称加密。

### 　　**(1)对称加密** ###

密钥可以自己指定，只有一把密钥。常用的对称加密算法有DES和AES两种。对称加密的速度快，但是缺点是安全性低，因为只要密钥暴漏，数据就可以被解密。

**AES加密解密使用：**

public class SymmetricEncoder {
        /*
         * 加密
         * 1.构造密钥生成器
         * 2.根据ecnodeRules规则初始化密钥生成器
         * 3.产生密钥
         * 4.创建和初始化密码器
         * 5.内容加密
         * 6.返回字符串
         */
        public static String AESEncode(String encodeRules,String content){
            try {
                //1.构造密钥生成器，指定为AES算法,不区分大小写
                KeyGenerator keygen=KeyGenerator.getInstance("AES");
                //2.根据ecnodeRules规则初始化密钥生成器
                //生成一个128位的随机源,根据传入的字节数组
                keygen.init(128, new SecureRandom(encodeRules.getBytes()));
                //3.产生原始对称密钥
                SecretKey original_key=keygen.generateKey();
                //4.获得原始对称密钥的字节数组
                byte [] raw=original_key.getEncoded();
                //5.根据字节数组生成AES密钥
                SecretKey key=new SecretKeySpec(raw, "AES");
                //6.根据指定算法AES自成密码器
                Cipher cipher=Cipher.getInstance("AES");
                //7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
                cipher.init(Cipher.ENCRYPT_MODE, key);
                //8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
                byte [] byte_encode=content.getBytes("utf-8");
                //9.根据密码器的初始化方式--加密：将数据加密
                byte [] byte_AES=cipher.doFinal(byte_encode);
                //10.将加密后的数据转换为字符串
                //这里用Base64Encoder中会找不到包
                //解决办法：
                //在项目的Build path中先移除JRE System Library，再添加库JRE System Library，重新编译后就一切正常了。
                String AES_encode=new String(new BASE64Encoder().encode(byte_AES));
                //11.将字符串返回
                return AES_encode;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
            //如果有错就返加null
            return null;
        }
        /*
         * 解密
         * 解密过程：
         * 1.同加密1-4步
         * 2.将加密后的字符串反纺成byte[]数组
         * 3.将加密内容解密
         */
        public static String AESDncode(String encodeRules,String content){
            try {
                //1.构造密钥生成器，指定为AES算法,不区分大小写
                KeyGenerator keygen=KeyGenerator.getInstance("AES");
                //2.根据ecnodeRules规则初始化密钥生成器
                //生成一个128位的随机源,根据传入的字节数组
                keygen.init(128, new SecureRandom(encodeRules.getBytes()));
                //3.产生原始对称密钥
                SecretKey original_key=keygen.generateKey();
                //4.获得原始对称密钥的字节数组
                byte [] raw=original_key.getEncoded();
                //5.根据字节数组生成AES密钥
                SecretKey key=new SecretKeySpec(raw, "AES");
                //6.根据指定算法AES自成密码器
                Cipher cipher=Cipher.getInstance("AES");
                //7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
                cipher.init(Cipher.DECRYPT_MODE, key);
                //8.将加密并编码后的内容解码成字节数组
                byte [] byte_content= new BASE64Decoder().decodeBuffer(content);
                /*
                 * 解密
                 */
                byte [] byte_decode=cipher.doFinal(byte_content);
                String AES_decode=new String(byte_decode,"utf-8");
                return AES_decode;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
    
            //如果有错就返加null
            return null;
        }
    
        public static void main(String[] args) {
            SymmetricEncoder se=new SymmetricEncoder();
            Scanner scanner=new Scanner(System.in);
            /*
             * 加密
             */
            System.out.println("使用AES对称加密，请输入加密的规则");
            String encodeRules=scanner.next();
            System.out.println("请输入要加密的内容:");
            String content = scanner.next();
            System.out.println("根据输入的规则"+encodeRules+"加密后的密文是:"+se.AESEncode(encodeRules, content));
    
            /*
             * 解密
             */
            System.out.println("使用AES对称解密，请输入加密的规则：(须与加密相同)");
            encodeRules=scanner.next();
            System.out.println("请输入要解密的内容（密文）:");
            content = scanner.next();
            System.out.println("根据输入的规则"+encodeRules+"解密后的明文是:"+se.AESDncode(encodeRules, content));
        }
    }

**DES加密解密使用：**

public class DESUtil {
        public static byte[] encode(String mes) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, InvalidKeySpecException, InvalidAlgorithmParameterException {
            SecureRandom random = new SecureRandom();
            // TODO: 2019/11/10 密钥长度应该是要大于8
            DESKeySpec desKey = new DESKeySpec("123abc123".getBytes());
            //创建一个密匙工厂，然后用它把DESKeySpec转换成
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            //Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
            return cipher.doFinal(mes.getBytes());
        }
    
        public static byte[] decode(byte[] encodeBytes) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException {
            // DES算法要求有一个可信任的随机数源
            SecureRandom random = new SecureRandom();
            // 创建一个DESKeySpec对象
            DESKeySpec desKey = new DESKeySpec("123abc123".getBytes());
            // 创建一个密匙工厂
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            // 将DESKeySpec对象转换成SecretKey对象
            SecretKey securekey = keyFactory.generateSecret(desKey);
            // Cipher对象实际完成解密操作
            Cipher cipher = Cipher.getInstance("DES");
            // 用密匙初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, securekey, random);
            // 真正开始解密操作
            return cipher.doFinal(encodeBytes);
        }
    }

### **(2)非对称加密** ###

常见的非对称加密算法是RSA；他有两把密钥，且是由程序生成的，不能自己指定；特点是加密速度比较慢，但是安全性比较高；加密和解密的规则是：公钥加密只能私钥解密，私钥加密只能公钥解密。

RSA对加密数据的长度有限制，一般为密钥的长度值-11，要加密较长的数据，可以采用数据截取的方法，分段加密。

使用场景：

文件或数据在本地使用公钥或私钥加密，加密后的数据传送到服务器，服务器使用同一套密钥中的私钥或者公钥进行解密。

public class RSAUtil {
        private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用于封装随机产生的公钥与私钥
        public static void main(String[] args) throws Exception {
            //生成公钥和私钥
            genKeyPair();
            //加密字符串
            String message = "abc12301230";
            Log.e(“aaa","随机生成的公钥为:" + keyMap.get(0));
            Log.e(“aaa","随机生成的私钥为:" + keyMap.get(1));
            String messageEn = encrypt(message,keyMap.get(0));
            Log.e(“aaa",message + "\t加密后的字符串为:" + messageEn);
            String messageDe = decrypt(messageEn,keyMap.get(1));
            Log.e(“aaa","还原后的字符串为:" + messageDe);
        }
    
        /**
         * 随机生成密钥对
         * @throws NoSuchAlgorithmException
         */
        public static void genKeyPair() throws NoSuchAlgorithmException {
            // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            // 初始化密钥对生成器，密钥大小为96-1024位
            keyPairGen.initialize(1024,new SecureRandom());
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥
            String publicKeyString = new String(Base64.encode(publicKey.getEncoded(), 0));
            // 得到私钥字符串
            String privateKeyString = new String(Base64.encode(privateKey.getEncoded(), 0));
            // 将公钥和私钥保存到Map
            keyMap.put(0,publicKeyString);  //0表示公钥
            keyMap.put(1,privateKeyString);  //1表示私钥
        }
        /**
         * RSA公钥加密
         *
         * @param str
         *            加密字符串
         * @param publicKey
         *            公钥
         * @return 密文
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static String encrypt(String str, String publicKey) throws Exception{
            //base64编码的公钥
            byte[] decoded = Base64.decode(publicKey, 0);
            RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
            //RSA加密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            String outStr = new String(Base64.encode(cipher.doFinal(str.getBytes("UTF-8")), 0));
            return outStr;
        }
    
        /**
         * RSA私钥解密
         *
         * @param str
         *            加密字符串
         * @param privateKey
         *            私钥
         * @return 铭文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static String decrypt(String str, String privateKey) throws Exception{
            //64位解码加密后的字符串
            byte[] inputByte = Base64.decode(str.getBytes(), 0);
            //base64编码的私钥
            byte[] decoded = Base64.decode(privateKey, 0);
            RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
            //RSA解密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, priKey);
            String outStr = new String(cipher.doFinal(inputByte));
            return outStr;
        }
    }