Android MD5,3DES,AES,RSA,Base64加解密

最新推荐文章于 2026-05-10 05:35:28 发布
原创 最新推荐文章于 2026-05-10 05:35:28 发布 · 617 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了Android中数据加密的几种常见方式，包括MD5单向加密、3DES对称加密、AES对称加密以及RSA非对称加密。同时，提到了Base64编码在数据传输中的应用。文章通过实例展示了如何使用这些加密算法，以确保数据在客户端与服务器间安全交互。

导言:
由于数据的安全性,所以需要进行数据加密和解密处理,所以本文只是记录一点

名词:
对称加密算法:加密和解密使用相同密钥的算法
异或加密算法:简单加密算法的一种,通过异或算法处理
RSA:公钥和私钥,非对称密码算法
Des:密钥加载,对称加密算法
Des3:DES加密算法的扩展，它使用3条64位的密钥对数据进行三次加密,DES向AES过渡的加密算法
Aes:区块,对称加密算法,用来替代Des
Md5:单向不可逆加密算法,但是也是可以编译的,用跑字典,解决方式多次加密和加盐
SHA:单向不可逆加密算法,Md5后继者,有SHA-1，SHA-2(SHA-224、SHA-384,SHA-512),如Google将使用SHA-2
Base64:对数据内容进行编码转换适合网络传输,由于传输过程中那些不可见ascii码被处理错误

步骤:
1:MD5加密,很简单,直接将需要加密的字符串传入即可.


public static String MD5Tool(String str) {
        if (TextUtils.isEmpty(str)) {
            return "";
        }
        try {
            MessageDigest mDigest = MessageDigest.getInstance("MD5");
            byte[] bytes = mDigest.digest(str.getBytes());
            String result = "";
            for (byte bt : bytes) {
                String temp = Integer.toHexString(bt & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result += temp;
            }
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

2:3DES重要加密解密类


public class DES3Util {
    private static final String TYPE = "DESede";

    //加密
    public static byte[] encryptMode(byte[] keybyte, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(keybyte, TYPE);
            Cipher c1 = Cipher.getInstance(TYPE);
            c1.init(Cipher.ENCRYPT_MODE, deskey);
            return c1.doFinal(src);
        } catch (java.security.NoSuchAlgorithmException e1) {
            e1.printStackTrace();
        } catch (javax.crypto.NoSuchPaddingException e2) {
            e2.printStackTrace();
        } catch (java.lang.Exception e3) {
            e3.printStackTrace();
        }
        return null;
    }

    //解密
    public static byte[] decryptMode(byte[] keybyte, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(keybyte, TYPE);
            Cipher c1 = Cipher.getInstance(TYPE);
            c1.init(Cipher.DECRYPT_MODE, deskey);
            return c1.doFinal(src);
        } catch (java.security.NoSuchAlgorithmException e1) {
            e1.printStackTrace();
        } catch (javax.crypto.NoSuchPaddingException e2) {
            e2.printStackTrace();
        } catch (java.lang.Exception e3) {
            e3.printStackTrace();
        }
        return null;
    }

    //byte->hexString
    public static String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1) hs = hs + "0" + stmp;
            else hs = hs + stmp;
            if (n < b.length - 1) hs = hs + "";
        }
        return hs.toUpperCase();
    }

    //hexString->byte
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
}

3:使用3DES加密解密样例

//三个不同秘钥
String key = "B1B2B3B4B5B6B7B8" + "A1A2A3A4A5A6A7A8" + "A1B2A3A4A5A6A7F8";
Sting src="1252142adfef@qq.com";
//加密
String encryResult = byte2hex(encryptMode(hexStringToBytes(key), src.getBytes("UTF-8")));
//解密
String decryptResult = new String(decryptMode(hexStringToBytes(key), hexStringToBytes(encryResult)), "UTF-8");

4:RSA,AES,Base64混合保证数据传递的安全性
释义:
RSA公钥和私钥通过Alipay_RSA签名工具生成,不要用代码生成,AES每次在客户端自动随机生成.

流程:android<—>服务器后台 是双向的
android:
1:RSA公钥a–加密–>AES秘钥b---->加密的AES秘钥c
2:AES秘钥b–加密–>原数据d---->加密数据e

服务器后台:
1:RSA私钥f–解密–>加密的AES秘钥c---->AES秘钥b
2:AES秘钥b–解密–>加密数据e---->原数据d

public class RSAESUtils {
    private static String sTransform = "RSA/NONE/PKCS1Padding";
    private static int sBase64Mode = Base64.DEFAULT;

    //RSA产生密钥对,经常通过第三方工具支付宝生成,而不是用代码生成,所以这个方法忽略
    public static KeyPair generateRSAKeyPair(int keyLength) {
        KeyPair keyPair = null;
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //设置密钥长度
            keyPairGenerator.initialize(keyLength);
            //产生密钥对
            keyPair = keyPairGenerator.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyPair;
    }

    //RSA加密或解密数据的通用方法
    private static byte[] processData(byte[] srcData, Key key, int mode) {
        //用来保存处理结果
        byte[] resultBytes = null;
        try {
            //获取Cipher实例
            Cipher cipher = Cipher.getInstance(sTransform);
            //初始化Cipher，mode指定是加密还是解密，key为公钥或私钥
            cipher.init(mode, key);
            //处理数据
            resultBytes = cipher.doFinal(srcData);
        } 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 resultBytes;
    }

    //RSA使用公钥加密数据，结果用Base64转码
    public static String encryptDataByPublicKey(byte[] srcData, PublicKey publicKey) {
        byte[] resultBytes = processData(srcData, publicKey, Cipher.ENCRYPT_MODE);
        return Base64.encodeToString(resultBytes, sBase64Mode);
    }

    //RSA使用私钥解密，返回解码数据
    public static byte[] decryptDataByPrivate(String encryptedData, PrivateKey privateKey) {
        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);
        return processData(bytes, privateKey, Cipher.DECRYPT_MODE);
    }

    //RSA使用私钥进行解密，解密数据转换为字符串，使用utf-8编码格式
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey) {
        return new String(decryptDataByPrivate(encryptedData, privateKey));
    }

    //RSA使用私钥解密，解密数据转换为字符串，并指定字符集
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey, String charset) {
        try {
            return new String(decryptDataByPrivate(encryptedData, privateKey), charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    //RSA使用私钥加密，结果用Base64转码
    public static String encryptDataByPrivateKey(byte[] srcData, PrivateKey privateKey) {
        byte[] resultBytes = processData(srcData, privateKey, Cipher.ENCRYPT_MODE);
        return Base64.encodeToString(resultBytes, sBase64Mode);
    }

    //RSA使用公钥解密，返回解密数据
    public static byte[] decryptDataByPublicKey(String encryptedData, PublicKey publicKey) {
        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);
        return processData(bytes, publicKey, Cipher.DECRYPT_MODE);
    }

    //RSA使用公钥解密，结果转换为字符串，使用默认字符集utf-8
    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey) {
        return new String(decryptDataByPublicKey(encryptedData, publicKey));
    }

    //RSA使用公钥解密，结果转换为字符串，使用指定字符集
    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey, String charset) {
        try {
            return new String(decryptDataByPublicKey(encryptedData, publicKey), charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    //RSA将字符串形式的公钥转换为公钥对象
    public static PublicKey keyStrToPublicKey(String publicKeyStr) {
        PublicKey publicKey = null;
        byte[] keyBytes = Base64.decode(publicKeyStr, sBase64Mode);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return publicKey;
    }

    //RSA将字符串形式的私钥，转换为私钥对象
    public static PrivateKey keyStrToPrivate(String privateKeyStr) {
        PrivateKey privateKey = null;
        byte[] keyBytes = Base64.decode(privateKeyStr, sBase64Mode);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            privateKey = keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }

    //生成AES秘钥
    public static byte[] generateAESKey(int keySize) {
        //保存AES密钥的字节数组
        byte[] keyBytes = null;
        try {
            //获取密钥生成器
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            //设置密钥长度，如果不调用该方法，默认生成256位的密钥
            keyGenerator.init(keySize);
            //获得密钥对象
            SecretKey secretKey = keyGenerator.generateKey();
            //转成字节数组
            keyBytes = secretKey.getEncoded();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyBytes;
    }

    //AES初始化向量IV
    private static byte[] generatorIvBytes(int blockSize) {
        Random random = new Random();
        byte[] ivParam = new byte[blockSize];
        for (int index = 0; index < blockSize; index++) {
            ivParam[index] = (byte) random.nextInt(256);
        }
        return ivParam;
    }

    //AES ECB模式加密
    public static String encryptDataByECB(String srcData) {
        String finalResult = null;
        //产生密钥
        byte[] keyBytes = generateAESKey(256);
        //构建SecretKeySpec，初始化Cipher对象时需要该参数
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //构建Cipher对象，需要传入一个字符串，格式必须为"algorithm/mode/padding"或者"algorithm/"
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            //初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            //加密数据
            byte[] resultBytes = cipher.doFinal(srcData.getBytes());
            //结果用Base64转码
            finalResult = Base64.encodeToString(resultBytes, Base64.DEFAULT);
        } 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 finalResult;
    }

    //AES ECB模式解密
    public static String decryptDataByECB(String srcData, byte[] keyBytes, String transform) {
        byte[] clearData = null;
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //根据格式获取Cipher实例，需与加密时一致
            Cipher cipher = Cipher.getInstance(transform);
            //初始化Cipher，注意这里变为解密模式
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            //先Base64解码
            byte[] temp = Base64.decode(srcData, Base64.DEFAULT);
            //解密数据
            clearData = cipher.doFinal(temp);
        } 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 new String(clearData);
    }

    //AES CBC模式加密
    public static String encryptDataByCBC(String srcData) {
        String finalResult = null;
        //产生密钥
        byte[] keyBytes = generateAESKey(256);
        //构建SecretKeySpec，初始化Cipher对象时需要该参数
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //构建Cipher对象，需要传入一个字符串，格式必须为"algorithm/mode/padding"或者"algorithm/"
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            //初始化Cipher对象
            byte[] ivBytes = generatorIvBytes(keyBytes.length);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivBytes);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            //加密数据
            byte[] resultBytes = cipher.doFinal(srcData.getBytes());
            //结果用Base64转码
            finalResult = Base64.encodeToString(resultBytes, Base64.DEFAULT);
        } 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();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return finalResult;
    }

    //AES CBC模式解密
    public static String decryptDataByCBC(String srcData, byte[] keyBytes, byte[] ivBytes, String transform) {
        byte[] clearData = null;
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //根据格式获取Cipher实例，需与加密时一致
            Cipher cipher = Cipher.getInstance(transform);
            //初始化Cipher，注意这里变为解密模式
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivBytes);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
            //先Base64解码
            byte[] temp = Base64.decode(srcData, Base64.DEFAULT);
            //解密数据
            clearData = cipher.doFinal(temp);
        } 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();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return new String(clearData);
    }
}

结束

Android数据加密之Des加密
01-20
前言：  有个同事咨询我有关Android DES加密的相关实现，简单的实现了一下，今天来总结一下。  其他几种加密方式：  •Android数据加密之Rsa加密  •Android数据加密之Aes加密  •Android数据加密之Des加密  •Android数据加密之MD5加密  •Android数据加密之Base64编码算法  •Android数据加密之SHA安全散列算法  DES加密介绍：       DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究， 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为D
乐易助手js调试工具。
05-26
乐易助手，js调试工具，包含MD5，DES,AES,RSA等多种算法。
macOS开发避坑指南：搞定‘文件和文件夹’权限，让你的App顺利读写桌面和下载目录
最新发布
weixin_33691700的博客
05-10 403
本文深入解析macOS开发中的文件权限管理，重点解决应用无法读写桌面和下载目录的常见问题。详细介绍了完全磁盘访问权限的配置方法、权限请求的最佳实践以及处理权限被拒的优雅降级方案，帮助开发者避开macOS沙盒机制下的权限陷阱，确保应用顺利访问用户目录。
3个著名加密算法(MD5、RSA、DES)的解析
weixin_33763244的博客
07-17 1358
MD5的全称是Message-Digest Algorithm 5，在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明，经MD2、MD3和MD4发展而来。 MD5将任意长度的“字节串”变换成一个128bit的大整数，并且它是一个不可逆的字符串变换算法，换句话说就是，即使你看到源程序和算法描述，也无法将一个MD5的值变换回原始的字符串，从数学原理上说，是...
js的3DES加密与解密
qq_42000201的博客
11-05 6178
3DES的加密与解密 Base64与Hex Base64与Hex都属于编码形式，Hex又称Base16。在3DES的加密与解密过程中，需要进行两种编码形式的转换。 3DES的加密 首先first.html代码为 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> ...
Android MD5加密类和Base64编解码类
安卓学习乐园
08-26 963
Android代码分享第五弹：一个实用的MD5加密类和BASE64编解码类。可能会有看官说这两个小功能，随便调用一下android的代码就OK了，但是当时我在搜索相关内容时还是发现，很多人提出相关的问题，并且还有很多乱七八糟的答案，尤其是MD5加密的类，竟然有个答案是会造成所有0消失，大错特错啊！于是花时间自己整理了一下，写出来，与诸位共享。 先看MD5加密的代码，先调用MessageDig
Android直播开发之旅(25)：使用AES算法加密多媒体文件(+RSA+MD5+Base64)
老蒋也疯狂
02-12 5129
文章目录1. AES算法1.1 AES加密过程1.1.1 字节代替(SubBytes)1.1.2 行移位(ShiftRows)1.1.3 列混合(MixColumns)1.1.4 加轮密钥(AddRoundKey)1.2 AES加解密实现1.2.1 创建密钥1.2.2 AES加密1.2.3 AES解密1.3 AES与DES的对比2. RSA算法2.1 RSA算法原理2.2 RSA加解密实现2.2....
Android 加解密算法工具类封装：AES、RSA、MD5 一站式解决方案
tangweiguo03051987的博客
03-09 946
在 Android 开发中，数据的安全性非常重要，尤其是敏感数据的存储和传输。为了实现数据加密和解密，我们可以封装一个通用的加解密工具类，支持常见的加密算法（如 AES、RSA、DES 等）。MD5 是一种广泛使用的哈希算法，通常用于生成数据的唯一摘要（哈希值）。以下是 MD5 工具类的封装，并附带使用示例。使用 decrypt() 方法，传入加密后的 Base64 编码字符串和私钥，返回解密后的原始数据。使用 encrypt() 方法，传入原始数据和公钥，返回加密后的 Base64 编码字符串。
Android数据加密之Rsa/MD5/Aes/Des加密算法归纳总结
心情舒畅
01-25 2995
加密算法 1.加密算法通常分为对称性加密算法和非对称性加密算法：对于对称性加密算法，信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的，之后便是对数据进行 加解密了。非对称算法与之不同，发送双方A,B事先均生成一堆密匙，然后A将自己的公有密匙发送给B，B将自己的公有密匙发送给A，如果A要给B发送消息，则先需要用B的公有密匙进行消息加密，然后发送给B端，此时B端再用自己的私有密匙进行消息解密...
Java实现Base64、DES、AES、RSA加解密以及加密方式之间的区别
凯腾凯的博客
10-11 1169
Base64 加密， 这个其实不可以算作加密方法，它可以看作是一种编码方式，它的用途只是二进制数字和字符串进行相互转化。 Base64是网络上最常见的用于传输 8Bit字节码的编码方式之一，是一种基于64个可打印字符来表示二进制数据的方法。Base64一般用于在 HTTP协议下传输二进制数据，由于 HTTP协议是文本协议，所以在 HTTP协议下传输二进制数据需要将二进制数据转换为字符数据。然而直接转换是不行的。因为网络传输只能传输可打印字符。 MD5加密 散列函数计算，一种不安全的加密算法，通常用于账号
Android MD5加密的实战应用与原理详解
Jm0218Xx的博客
06-17 3775
本文详细介绍了MD5工具类的Java实现，包含字符串和文件的MD5计算方法。工具类采用位运算高效转换字节为十六进制，优化文件处理使用8KB缓冲区和try-with-resources。虽然MD5存在安全风险，但仍适用于文件校验等非敏感场景。对于密码存储，推荐使用BCrypt等更安全的算法。文章提供了完整的代码实现和使用示例，并指出了MD5的适用场景和局限性。
JS端与java(android)端3DES加密解密和Base64编码解码文件
05-23
使用详情看博客: https://blog.csdn.net/bob_Xing_Yang/article/details/80417383
Android 采用MD5注册登录，加密解密
06-19
Android 采用MD5注册登录，加密解密 https://blog.csdn.net/qq_31939617/article/details/80728459
android用MD5加密解密demo
06-03
android用MD5加密解密简单demo
java 3des加密、sha256加密、byte数组转hex
just_Keep_Smile的博客
10-14 2193
3des： import java.security.Security; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.io.*; import java.util.Arrays; public class Encrypt...
DES，RAS，HASH
NI3E
06-01 1350
原理和实现代码
3DES 加密解密
lln93988的博客
12-12 422
C# 3DES加密解密
Android开发 客户端的用户密码MD5加密算法
彬sir哥的博客
08-12 1127
客户端的用户密码加密,如下 String *** = EnDecryptUtil.MD5HexEncrypt(password.toString()); MD5加密： MD5是不可逆的加密算法，也就是无法解密，主要用于客户端的用户密码加密。MD5算法加密代码如下： EnDecryptUtil类：加密,EnDecrypt就是加解密 public class EnDecryptUtil { ...... //加密 public static String MD5HexEncrypt(String p
Android常用加解密算法
笔沫拾光
09-07 3703
数据安全，不管是对于企业还是个人都是十分重要。而作为一个移动开发者，我们更需要去考虑数据传输的安全性，去保护企业及个人信息安全。在Java,Android语言中，有许多的常用加解密算法，例如：对称加密算法AES,DES,3DES，非对称加密算法RSA,经典哈希算法MD5,SHA. 对称加密算法：加密秘钥和解密秘钥相同 例：AES,DES,3DES 非对称加密算法：有公钥和秘钥，公钥加密
Android传输数据时MD5加密解密详解
LKing的博客
09-04 6982
Android传输数据时MD5加密详解 MD5加密算法 一、特点 1. 长度固定：不管多长的字符串，加密后长度都是一样长。方便信息的统计和管理。 2. 易计算：字符串和文件加密的过程容易。开发者很容易理解和做出加密工具。 3. 抗修改：对原数据哪怕只有一个字节的修改，得到的MD5值都有很大区别 4. 不可逆：知道密文和加密方式，却无法反向计算出原密码。 注： v md5加密无法找回...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值