浅析五种最常用的Java加密算法，以后可以直接拿来用了

最新推荐文章于 2024-08-29 14:58:09 发布
最新推荐文章于 2024-08-29 14:58:09 发布
阅读量545 收藏 2
点赞数 2
分类专栏： java高级 文章标签： java 密码学 加密解密 安全 md5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39363245/article/details/114829844
版权

一）关于加密算法

信息加密是现在几乎所有项目都需要用到的技术，身份认证、单点登陆、信息通讯、支付交易等场景中经常会需要用到加密算法，所谓加密算法，就是将原本的明文通过一系列算法操作变成密文。接下来就介绍一下目前比较常用的一些加密算法，本期不涉及算法底层，以应用介绍和代码展示为主。

如果只想了解原理，可跳过代码部分，代码可直接拿来使用。

（二）MD5算法

准确来讲，MD5不是一种加密算法，而是一种摘要算法，MD5能将明文输出为128bits的字符串，这个字符串是无法再被转换成明文的。网上一些MD5解密网站也只是保存了一些字符串对应的md5串，通过已经记录的md5串来找出原文。

我做过的几个项目中经常见到MD5用在加密上的场景。比如对密码的加密，生成一个密码后，使用MD5生成一个128位字符串保存在数据库中，用户输入密码后也先生成MD5串，再去数据库里比较。因此我们在找回密码时是无法得到原来的密码的，因为明文密码根本不会被保存。

public class MD5 {
    /**
     * 生成MD5
     * @param str
     * @return
     */
    public String encode(String str) {
        byte[] result = null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(str.getBytes("UTF-8"));
            result = md.digest();

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return parseByte2HexStr(result);
    }

    /**
     * 将二进制转换成十六进制
     *
     * @param buf
     * @return
     */
    private String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        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();
    }

    public static void main(String[] args) {
        MD5 md5=new MD5();
        String content = "测试test";
        System.out.println(md5.encode(content));
    }
}
复制代码

（三）SHA1算法

SHA1也是和MD5类似的信息摘要算法，但是它比MD5更加安全。

public class SHA1 {
    public String encode(String str) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            md.update(str.getBytes("utf-8"));
            byte[] digest = md.digest();
            return byteToHexString(digest);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public static String byteToHexString(byte[] bytes) {
        return String.valueOf(Hex.encodeHex(bytes));
    }
    public static void main(String[] args) {
        SHA1 sha1 = new SHA1();
        String content = "测试test";
        System.out.println(sha1.encode(content));
    }
}
复制代码

（四）AES算法

AES是很常见的对称加密算法，所谓对称加密，就是通过密钥加密后可以再通过密钥解密。我接触过的某个国企现在内部就是采用AES的方式实现集成登陆。第三方系统提供一个接收用户信息的接口，该国企将用户信息AES加密后通过这个接口传递给第三方系统，第三方系统自行实现登陆操作。这里需要注意的是密钥十分重要，如果密钥丢失，就有信息泄漏的风险。

public class AES {
    /**
     * 将传入的明文转换为密文
     * @param str
     * @param pwd
     * @return
     */
    public String encode(String str,String pwd) {
        byte[] result = null;
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(pwd.getBytes());
            kgen.init(128, random);
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");

            // 创建密码器
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] byteContent = str.getBytes();
            result = cipher.doFinal(byteContent);

        } catch (Exception e) {
            return null;
        }

        return parseByte2HexStr(result);
    }

    /**
     * 将传入的密文转换为明文
     * @param str
     * @param pwd
     * @return
     */
    public String decode(String str,String pwd) {
        byte[] result = null;
        byte[] content = parseHexStr2Byte(str);
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(pwd.getBytes());
            kgen.init(128, random);
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");

            // 创建密码器
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(content);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return new String(result);
    }

    /**
     * 将二进制转换成十六进制
     *
     * @param buf
     * @return
     */
    private String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        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();
    }

    /**
     * 将十六进制转换为二进制
     *
     * @param hexStr
     * @return
     */
    private 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;
    }
    
    public static void main(String[] args) {
        AES aes = new AES();
        String content = "测试加密";
        // AES的密钥长度最好是16位(不是必须)
        String pwd = "javayznbjavayznb";

        // 加密
        System.out.println("加密前：" + content);
      String encodeResultStr = aes.encode(content,pwd);
      System.out.println("加密后：" + encodeResultStr);
      // 解密
      String decodeResultStr = aes.decode(encodeResultStr,pwd);
      System.out.println("解密后：" + decodeResultStr);
    }

}
复制代码

（五）DES

DES也是一种对称加密算法，但是在安全性、效率和灵活性上比AES略差，但是也能保证安全，DES也需要通过密钥进行加密，通过密钥进行解密，因此密钥很重要：

public class DES {
    /**
     * 将传入的明文转换为密文
     * @param str
     * @param pwd
     * @return
     */
    public String encode(String str,String pwd) {
        byte[] result = null;
        try {
            DESKeySpec keySpec = new DESKeySpec(pwd.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey key = keyFactory.generateSecret(keySpec);

            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] byteContent = str.getBytes();
            result = cipher.doFinal(byteContent);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return parseByte2HexStr(result);
    }

    /**
     * 将传入的密文转换为明文
     * @param str
     * @param pwd
     * @return
     */
    public String decode(String str,String pwd) {
        byte[] result = null;
        byte[] content = parseHexStr2Byte(str);
        try {
            DESKeySpec keySpec = new DESKeySpec(pwd.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey key = keyFactory.generateSecret(keySpec);

            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(content);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return new String(result);
    }

    /**
     * 将二进制转换成十六进制
     *
     * @param buf
     * @return
     */
    private String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        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();
    }

    /**
     * 将十六进制转换为二进制
     *
     * @param hexStr
     * @return
     */
    private 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;
    }

    public static void main(String[] args) {
        DES des = new DES();
        String content = "测试test";
        // DES的密钥长度必须是8位(小于8位则会报错，8位之后对加密结果不会产生影响)
        String pwd = "javayznb";
        // 加密
        System.out.println("加密前：" + content);
        String encodeResultStr = des.encode(content,pwd);
        System.out.println("加密后：" + encodeResultStr);
        //解密
        String decodeResultStr = des.decode(encodeResultStr,pwd);
        System.out.println("解密后：" + decodeResultStr);
    }
}
复制代码

（六）RSA

RSA是目前最具影响力的公钥加密算法，并且可以用于加密和验签。支付宝支付对接时用的加密方式就是RSA。在RSA中，存在一对密钥，分别称为公钥和私钥，通过私钥由个人保存，公钥可能多人持有。

RSA的主要应用场景就是加密和验签，加密就不用说了，验签是指通过私钥对消息进行签名，使得消息无法篡改和伪造。

加密方式：B传加密数据给A

1、A生成公钥和私钥，私钥自己保留，公钥任何人可以获取。

2、B拿到公钥，将数据通过公钥加密

3、A收到密文，通过私钥解密。

验签方式：A传消息给B 1、A生成公钥和私钥，私钥自己保留，公钥任何人可以获取。

2、A使用私钥对消息加签，并将加签后的消息传给B。

3、B通过公钥验签，如果返回是true则说明消息是A发过来的且未被篡改。

public class TestRSA {

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * 获取密钥对
     *
     * @return 密钥对
     */
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
        generator.initialize(1024);
        return generator.generateKeyPair();
    }

    /**
     * 获取私钥
     *
     * @param privateKey 私钥字符串
     * @return
     */
    public static PrivateKey getPrivateKey(String privateKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 获取公钥
     *
     * @param publicKey 公钥字符串
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * RSA加密
     *
     * @param data 待加密数据
     * @param publicKey 公钥
     * @return
     */
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int inputLen = data.getBytes().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.getBytes(), offset, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
            }
            out.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
        // 加密后的字符串
        return new String(Base64.encodeBase64String(encryptedData));
    }

    /**
     * RSA解密
     *
     * @param data 待解密数据
     * @param privateKey 私钥
     * @return
     */
    public static String decrypt(String data, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] dataBytes = Base64.decodeBase64(data);
        int inputLen = dataBytes.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(dataBytes, offset, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
            }
            out.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        // 解密后的内容
        return new String(decryptedData, "UTF-8");
    }

    /**
     * 签名
     *
     * @param data 待签名数据
     * @param privateKey 私钥
     * @return 签名
     */
    public static String sign(String data, PrivateKey privateKey) throws Exception {
        byte[] keyBytes = privateKey.getEncoded();
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey key = keyFactory.generatePrivate(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(key);
        signature.update(data.getBytes());
        return new String(Base64.encodeBase64(signature.sign()));
    }

    /**
     * 验签
     *
     * @param srcData 原始字符串
     * @param publicKey 公钥
     * @param sign 签名
     * @return 是否验签通过
     */
    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
        byte[] keyBytes = publicKey.getEncoded();
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey key = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(key);
        signature.update(srcData.getBytes());
        return signature.verify(Base64.decodeBase64(sign.getBytes()));
    }

    public static void main(String[] args) {
        try {
            // 生成密钥对
            KeyPair keyPair = getKeyPair();
            String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
            String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
            System.out.println("私钥:" + privateKey);
            System.out.println("公钥:" + publicKey);
            // RSA加密
            String data = "待加密的文字内容";
            String encryptData = encrypt(data, getPublicKey(publicKey));
            System.out.println("加密后内容:" + encryptData);
            // RSA解密
            String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
            System.out.println("解密后内容:" + decryptData);
            // RSA签名
            String sign = sign(data, getPrivateKey(privateKey));
            System.out.println("加签后："+sign);
            // RSA验签
            boolean result = verify(data, getPublicKey(publicKey), sign);
            System.out.print("验签结果:" + result);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.print("加解密异常");
        }
    }
}
复制代码

（七）总结

关于加密这个问题不管是工作中还是面试中都会被提及，也必须要掌握。不要求加密的代码能手写，但是要知道每种加密算法是干什么的，是什么样的效果。

本文首发于java黑洞网，csdn同步更新

 

喜欢安静的程序猿
关注
专栏目录
Java的加密算法
码出精彩
05-11 458
Java的加密算法Java的加密算法1. JDK提供的Base64编码操作Base64Util工具类测试方法：2. 消息摘要算法（MD5、SHA、HMAC）BytesToHex 工具类MessageDigestUtil 工具类测试方法：测试结果：3. 对称加密算法（DES、3DES、AES）DESUtil 工具类测试方法：测试结果：4. 非对称加密算法（DH、RSA）DHUtil 类测试方法：RSAUtil 工具类测试方法：测试截图：5. 数字签名算法（RSA、DSA）RSASignatureUtil 工具
浅析JWT| JWT是啥子，Java构建JWT
可乐的博客
01-26 4307
小声bbb 说到系统的安全识别，记得自己第一个项目，用的就是session，用户登录进来以后，给他session标记登录，记录id进去，轻轻松松，设计的操作也很简单，类似操作HashMap。 这大概也有1年多快两年了，现在回头看真的是可怕，几乎在裸奔 众所周知，平常使用的Session是存储在服务器的一种技术，可以理解为一个会话id，每次使用HTTP请求，都会携带一个sessionId，服务器根据这个SessionId去找对应的session しかし，我预判了你的预判 第三方完全可以随便输入一个sess
Java常用的加密方式
最新发布
刘皇叔说Java的博客
08-29 1148
在Java开发中，常用的加密方式包括以下几种MessageDigest（消息摘要）：Java提供了java.security.MessageDigest类来进行散列算法的使用。通过MessageDigest类可以计算数据的哈希值，例如使用SHA-256、MD5等算法对用户信息进行散列处理。AES（高级加密标准）：AES是一种常用的对称加密算法，适用于保护用户敏感信息。Java中可以使用javax.crypto包下的相关类进行AES加密和解密操作。
java加密算法
不积跬步 无以至千里 不积小流 无以成江海
08-26 150
感谢：http://www.iteye.com/wiki/security/1710-one-way-encryption-algorithm         http://sarin.iteye.com/blog/600045    ●  BASE64 严格地说，属于编码格式，而非加密算法    ●  MD5(Message Digest algorithm 5，信息摘要算法)    ●  SH...
Java中常用的加密算法应用
sabob的专栏
11-29 503
1. MD5加密，常用于加密用户名密码，当用户验证时。　 　protected byte[] encrypt(byte[] obj) ...{ 　　try ...{ 　　MessageDigest md5 = MessageDigest.getInstance("MD5"); 　　md5.update(obj); 　　return md5.digest(); 　　} catch (NoSuchAl
Java 加密算法
weixin_51008360的博客
09-02 1003
加密算法 对原来为明文的文件或数据按某中算法进行处理，使其成为不可读的一段代码。 保密性：防止用户的标识或数据被读取。 数据完整性：防止数据被更改。 身份验证：确保数据发自特定的一方。 加密算法可以归结为三大类： 哈希算法、对称加密算法、非对称加密算法。 常见的 对称加密 算法主要有 DES、3DES、AES 等，常见的 非对称算法 主要有 RSA、DSA 等，散列算法 主要有 SHA-1、MD5 等 对称式加密 对称式加密就是加密和解密使用同一个密钥，通常称之为“Session Key ”。 DES（Da
Java后台开发面经汇总
weixin_44587820的博客
04-19 1168
2021Java后台开发面经汇总+面试复习 写在前面： 内容颇多，博主不断追更，根据左下方“文章目录”可对所需内容快速跳转???? HTTP和HTTPS协议区别 区别： https://blog.csdn.net/xiaoming100001/article/details/81109617 SSL（https）的加密方法???? 理解SSL（https）中的对称加密与非对称加密： https://www.cnblogs.com/hai-blog/p/8311671.html 用邮局的例子来解释下对称
浅析微信支付：申请退款、退款回调接口、查询退款
weixin_34332905的博客
11-08 1131
本文是【浅析微信支付】系列文章的第八篇，主要讲解商户如何处理微信申请退款、退款回调、查询退款接口，其中有一些坑的地方，会着重强调。 浅析微信支付系列已经更新七篇了哟～，没有看过的朋友们可以看一下哦。 浅析微信支付：查询订单和关闭订单 浅析微信支付：支付结果通知 浅析微信支付：统一下单接口 在实际场景中，申请退款和退款回调接口是比较常用到的微信支付接口，这里我们会讲原路返回方式的退款，还有的是...
Java面试所需的知识
Tona_ZM的博客
11-15 2850
目录 1. 计算机网络 （1）网络7层架构 （2）TCP/IP原理 （3）HTTP原理 （4）加密算法 2. 数据结构 3. 算法 （1） Java算法 （2）海量数据处理 4. 操作系统 5. MySQL数据库 1、事务 2、数据库结构和锁 3、索引 4、情景题、优化题 5、琐碎知识 6、视图 7、存储过程和触发器 8、约束 6. Redis数据库...
java的加密算法_几种JAVA加密算法
weixin_39568781的博客
02-20 97
1. MD5加密，常用于加密用户名密码，当用户验证时。protected byte[] encrypt(byte[] obj) ...{try ...{MessageDigest md5 = MessageDigest.getInstance("MD5");md5.update(obj);return md5.digest();} catch (NoSuchAlgorithmException e...
JAVA 加密算法(很好的算法,经典摘要)
10-06
JAVA 加密算法(很好的算法,经典摘要)
java算法教程
03-24
java的算法教程，里面讲述java的算法，文档类型，有解释说明，非常详细
分享Java常用几种加密算法(四种)
09-03
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。本文给大家分享java常用的几种加密算法，需要的朋友可以参考下
java 加密算法
hudeyong926的专栏
03-16 215
MD5和SHA1 public static String SHA1(String decript) { try { MessageDigest digest = MessageDigest.getInstance("SHA-1"); digest.update(decript.getBytes()); byte messageDigest[] = digest.digest(); StringBuffer hexString =
Java常用加密算法
Java十年君
04-01 4059
Java加密技术
Java中的各种加密算法
热门推荐
01-04 1万+
JAVA中为我们提供了丰富的加密技术，可以基本的分为单向加密和非对称加密 1.单向加密算法 单向加密算法主要用来验证数据传输的过程中，是否被篡改过。BASE64 严格地说，属于编码格式，而非加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authenticati
java各种加密算法_Java中的各种加密算法
weixin_36267013的博客
02-16 1999
JAVA中为我们提供了丰富的加密技术，可以基本的分为单向加密和非对称加密1.单向加密算法单向加密算法主要用来验证数据传输的过程中，是否被篡改过。BASE64 严格地说，属于编码格式，而非加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authentication...
浅析加密技术：流行算法与生活中的加密解密
《加密技术及加密的流行算法》这篇文档深入探讨了这一主题，展示了加密如何无处不在，从日常生活的密码保护到企业级的数据保密，都离不开加密的运用。 首先，文章解释了什么是加密。在信息时代，加密技术通过复杂的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值