java加密、解密、编码

已于 2023-11-21 09:58:03 修改
阅读量282 收藏 1
点赞数 1
文章标签： java 开发语言
于 2023-08-03 17:22:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zqy123456_123/article/details/132085177
版权

目录

 一、加密--解密

1.Base64

        jdk1.7:

        jdk1.8:

2.AES

3.RSA

 一、加密--解密

1.Base64

        jdk1.7:

String str="张三";
BASE64Encoder encoder = new BASE64Encoder();
//加密
String encode=encoder.encode(str.getBytes());
//解密
String decode=new String(decoder.decodeBuffer(str))

        jdk1.8:

package com.test.utils;

import org.apache.tomcat.util.codec.binary.Base64;

import java.io.UnsupportedEncodingException;

/**
 * @Author:
 * @CreateTime: 2023-08-03  16:27
 * @Description: Base64加密解密工具类
 */
public class Base64Utils {
    /**
     * 字符编码
     */
    public final static String ENCODING = "UTF-8";

    /**
     * @description: Base64编码
     * @author:
     * @date: 2023/8/3 16:31
     * @param: [data] 待编码数据
     * @return: java.lang.String 编码数据
     **/
    public static String encode(String data) {
        try {
            byte[] b = Base64.encodeBase64(data.getBytes(ENCODING));
            return new String(b, ENCODING);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @description: Base64安全编码 遵循RFC 2045实现
     * @author:
     * @date: 2023/8/3 16:33
     * @param: [data] 待编码数据
     * @return: java.lang.String 编码数据
     **/
    public static String encodeSafe(String data) {
        try {
            byte[] b = Base64.encodeBase64(data.getBytes(ENCODING), true);
            return new String(b, ENCODING);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @description: Base64解码
     * @author: zhangqingyun
     * @date: 2023/8/3 16:35
     * @param: [data] 待解码数据
     * @return: java.lang.String 解码数据
     **/
    public static String decode(String data) {
        try {
            byte[] b = Base64.decodeBase64(data.getBytes(ENCODING));
            return new String(b, ENCODING);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

2.AES

package com.test.utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

/**
 * @Author:
 * @CreateTime: 2023-08-03  16:50
 * @Description: Aes加密解密工具类
 */
public class AesUtils {
    private static final String KEY_AES = "AES";

    private static final int KEY_LENGTH = 16;

    private static final String KEY = "aWXoyC4UNb137965";//秘钥

    /**
     * @description: Aes加密
     * @author:
     * @date: 2022/10/18 14:15
     * @param: [data] 待编码数据
     * @return: java.lang.String  编码数据
     **/
    public static String encrypt(String data) {
        try {
            if (KEY == null || KEY.length() != KEY_LENGTH) {
                throw new IllegalArgumentException("密钥长度必须是16位");
            }
            byte[] raw = KEY.getBytes();
            SecretKeySpec skySpec = new SecretKeySpec(raw, KEY_AES);
            Cipher cipher = Cipher.getInstance(KEY_AES);
            cipher.init(Cipher.ENCRYPT_MODE, skySpec);
            byte[] encrypted = cipher.doFinal(data.getBytes());
            return byte2hex(encrypted);
        } catch (Exception e) {
            System.out.println("AES加密方法出错" + e);
        }
        return null;
    }

    /**
     * @description: Aes解密
     * @author:
     * @date: 2022/10/18 14:16
     * @param: [data] 待解码数据
     * @return: java.lang.String 解码数据
     **/
    public static String decrypt(String data) {
        try {
            if (KEY == null || KEY.length() != KEY_LENGTH) {
                throw new IllegalArgumentException("密钥长度必须是16位");
            }
            byte[] raw = KEY.getBytes();
            SecretKeySpec skySpec = new SecretKeySpec(raw, KEY_AES);
            Cipher cipher = Cipher.getInstance(KEY_AES);
            cipher.init(Cipher.DECRYPT_MODE, skySpec);
            byte[] encrypted1 = hex2byte(data);
            byte[] original = cipher.doFinal(encrypted1);
            return new String(original);
        } catch (Exception e) {
            System.out.println("AES解密出错" + e);
        }
        return null;
    }

    /**
     * @description: Aes对称加密算法---加密
     * @author: zhangqingyun
     * @date: 2023/8/3 17:10
     * @param: [data] 待编码数据
     * @return: java.lang.String 编码数据
     **/
    public static String encryptWithAES(String data) {
        byte[] encryptedBytes = null;
        try {
            Cipher cipher = Cipher.getInstance(KEY_AES);
            SecretKey secretKey = generateAESKey(KEY);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
    
    /**
     * @description: Aes对称加密算法---解密
     * @author: zhangqingyun
     * @date: 2023/8/3 17:13
     * @param: [data] 待解码数据
     * @return: java.lang.String 解码数据
     **/
    public static String decryptWithAES(String data) {
        byte[] decryptedBytes = new byte[0];
        try {
            Cipher cipher = Cipher.getInstance(KEY_AES);
            SecretKey secretKey = generateAESKey(KEY);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(data));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }

    public static byte[] hex2byte(String hex) {
        if (hex == null) {
            return new byte[0];
        }
        int l = hex.length();
        int n = 2;
        if (l % n == 1) {
            return new byte[0];
        }
        byte[] b = new byte[l / 2];
        for (int i = 0; i != l / n; i++) {
            b[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2),
                    16);
        }
        return b;
    }

    public static String byte2hex(byte[] b) {
        StringBuilder hs = new StringBuilder();
        String tmp;
        for (byte value : b) {
            tmp = (Integer.toHexString(value & 0XFF));
            if (tmp.length() == 1) {
                hs.append("0").append(tmp);
            } else {
                hs.append(tmp);
            }
        }
        return hs.toString().toUpperCase();
    }

    /**
     * @description: 生成AES密钥
     * @author:
     * @date: 2023/8/3 17:05
     * @param: [password] 密码
     * @return: javax.crypto.SecretKey 密钥
     **/
    private static SecretKey generateAESKey(String password) {
        byte[] keyBytes = null;
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_AES);
            keyGenerator.init(128);
            byte[] passwordBytes = password.getBytes(StandardCharsets.UTF_8);
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            keyBytes = digest.digest(passwordBytes);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return new SecretKeySpec(keyBytes, KEY_AES);
    }
}

3.RSA

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Author:
 * @CreateTime: 2023-09-13  16:50
 * @Description: RSA加密解密工具类
 */
public class RSAUtils {
    /**
     * 非对称加密密钥算法
     */
    public static final String KEY_ALGORITHM_RSA = "RSA";

    /**
     * 公钥
     */
    private static final String RSA_PUBLIC_KEY = "RSAPublicKey";

    /**
     * 私钥
     */
    private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";

    /**
     * RSA密钥长度
     * 默认1024位，
     * 密钥长度必须是64的倍数，
     * 范围在512至65536位之间。
     */
    private static final int KEY_SIZE = 1024;

    /**
     * 私钥解密
     *
     * @param data
     *            待解密数据
     * @param key
     *            私钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
            throws Exception {

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        int blockSize = cipher.getBlockSize();
        if(blockSize>0){
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
            int j = 0;
            while (data.length - j * blockSize > 0) {
                bout.write(cipher.doFinal(data, j * blockSize, blockSize));
                j++;
            }
            return bout.toByteArray();
        }
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data
     *            待解密数据
     * @param key
     *            公钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key)
            throws Exception {

        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

        // 生成公钥
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        return cipher.doFinal(data);
    }

    /**
     * 公钥加密
     *
     * @param data
     *            待加密数据
     * @param key
     *            公钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key)
            throws Exception {

        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        int blockSize = cipher.getBlockSize();
        if(blockSize>0){
            int outputSize = cipher.getOutputSize(data.length);
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
                    : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0,remainSize=0;
            while ((remainSize = data.length - i * blockSize) > 0) {
                int inputLen = remainSize > blockSize?blockSize:remainSize;
                cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
                i++;
            }
            return raw;
        }
        return cipher.doFinal(data);
    }

    /**
     * 私钥加密
     *
     * @param data
     *            待加密数据
     * @param key
     *            私钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
            throws Exception {

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        int blockSize = cipher.getBlockSize();
        if(blockSize>0){
            int outputSize = cipher.getOutputSize(data.length);
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
                    : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0,remainSize=0;
            while ((remainSize = data.length - i * blockSize) > 0) {
                int inputLen = remainSize > blockSize?blockSize:remainSize;
                cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
                i++;
            }
            return raw;
        }
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap
     *            密钥Map
     * @return key 私钥
     * @throws Exception
     */
    public static Key getPrivateKey(Map<String, Key> keyMap)
            throws Exception {
        return keyMap.get(RSA_PRIVATE_KEY);
    }

    /**
     * 取得私钥
     *
     * @param keyMap
     *            密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)
            throws Exception {
        return keyMap.get(RSA_PRIVATE_KEY).getEncoded();
    }

    /**
     * 取得公钥
     *
     * @param keyMap
     *            密钥Map
     * @return key 公钥
     * @throws Exception
     */
    public static Key getPublicKey(Map<String, Key> keyMap)
            throws Exception {
        return keyMap.get(RSA_PUBLIC_KEY);
    }

    /**
     * 取得公钥
     *
     * @param keyMap
     *            密钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKeyByte(Map<String, Key> keyMap)
            throws Exception {
        return keyMap.get(RSA_PUBLIC_KEY).getEncoded();
    }

    /**
     * 初始化密钥
     * @param seed 种子
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String,Key> initKey(byte[] seed)throws Exception{
        // 实例化密钥对生成器
        KeyPairGenerator keyPairGen = KeyPairGenerator
                .getInstance(KEY_ALGORITHM_RSA);

        // 初始化密钥对生成器
        keyPairGen.initialize(KEY_SIZE, new SecureRandom(seed) );

        // 生成密钥对
        KeyPair keyPair = keyPairGen.generateKeyPair();

        // 公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

        // 私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        // 封装密钥
        Map<String, Key> keyMap = new HashMap<String, Key>(2);

        keyMap.put(RSA_PUBLIC_KEY, publicKey);
        keyMap.put(RSA_PRIVATE_KEY, privateKey);

        return keyMap;
    }

    /**
     * 初始化密钥
     * @param seed 种子
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String,Key> initKey(String seed)throws Exception{
        return initKey(seed.getBytes());
    }

    /**
     * 初始化密钥
     *
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String, Key> initKey() throws Exception {
        return initKey(UUID.randomUUID().toString().getBytes());
    }

    public static PublicKey getPublicRSAKey(String key) throws Exception {
        X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.getDecoder().decode(key));
        KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
        return kf.generatePublic(x509);
    }

    public static PrivateKey getPrivateRSAKey(String key) throws Exception {
        PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(key));
        KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
        return kf.generatePrivate(pkgs8);
    }

}

4.MD5

package com.test.utils;

import org.springframework.util.DigestUtils;

/**
 * @Author: zhangqingyun
 * @CreateTime: 2023-09-13  16:24
 * @Description: MD5加密解密工具类
 */
public class MD5Util {
    /**
     * MD5加密
     *
     * @param data 待加密数据
     * @return byte[] 消息摘要
     * @throws Exception
     */
    public static byte[] encodeMD5(String data) throws Exception {

        // 执行消息摘要
        return DigestUtils.md5Digest(data.getBytes());
    }

    /**
     * MD5加密
     *
     * @param data 待加密数据
     * @return byte[] 消息摘要
     * @throws Exception
     */
    public static String encodeMD5Hex(String data) {
        // 执行消息摘要
        return DigestUtils.md5DigestAsHex(data.getBytes());
    }
}

清水映云
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 实现 Base64 加密&解密方法
JavaMonsterr的博客
06-04 3万+
Base64 编码是程序开发中比较常用的一种编码算法，是常用来存储或传输一些二进制数据的方法，也是 MIME（多用途互联网邮件扩展）中的一种编码方法 。Base64 可以实现将任何数据转换为可打印字符表示的字符串，避免数据在传输过程中失真，Base64 最开始用来在邮件发送中将非 ASCLL 字符内容转换为 ASCLL字符。标准 Base64 是一种用于传输 8Bit 字节码的编码方式之一，基于 64 个可打印字符来表示二进制数据，使用的可打印字符包括有：A-Z、a-z、0-9、+、/ 共 64 个。Url
JAVA各种加密与解密方式
a10534126的博客
05-29 907
之前有兴趣研究了一下java的加密与解密的方法，发现市面上有好多种加密解密方式，在这里整理了一下。 目录 1.BASE64加密/解密 2.MD5(Message Digest Algorithm)加密 3.DES(Data Encryption Standard)对称加密/解密 4.AES（Advanced Encryption Standard） 加密/解密 5.HMAC(Hash Message Authentication Code，散列消息鉴别码) 6.恺撒加密 7.SHA(Secure Hash
java多种加密和解密方式
guanshengg的博客
08-20 1万+
Base64 编码是我们程序开发中经常使用到的编码方法，它用 64 个可打印字符来表示二进制数据。这 64 个字符是：小写字母 a-z、大写字母 A-Z、数字 0-9、符号"+"、"/"（再加上作为垫字的"="，实际上是 65 个字符），其他所有符号都转换成这个字符集中的字符。Base64 编码通常用作存储、传输一些二进制数据编码方法，所以说它本质上是一种将二进制数据转成文本数据的方案
Java加密与解密的艺术~MessageDigest
小强快跑~~
11-20 1440
MessageDigest类实现了消息摘要算法，它继承于MessageDigestSpi类，是Java安全提供者体系结构中最简单的一个引擎类。 在Java API的列表中，总能看到后缀名带有SPI（Service Provider Interface）的类。如果要实现自定义的消息摘要算法，则需要提供MessageDigestSpi类的子类实现 使用示例 import java.security.MessageDigest; import org.bouncycastle.jce.provider.B
Java加密解密介绍
最新发布
2401_84002594的博客
05-23 575
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优/**
MD5加密解密
weixin_46654971的博客
03-30 3346
要用statement类的executeQuery()方法来下达select指令以查询数据库，executeQuery()方法会把数据库响应的查询结果存放在。Java中利用MessageDigest获取字符串或文件MD5,MessageDigest是Java自带的类。类对象中供我们使用。即语句：ResultSet rs=s.executeQuery(sql);1. 任何时候，都需要对密码进行加密。2.executeQuery()方法。
flutter加密java解密
02-23
同时，为了调试方便，可以使用测试用例和伪随机数据进行加密解密测试，验证各环节的正确性。 8. **安全最佳实践**：遵循安全编码规范，比如不要硬编码密钥，定期更换密钥，避免明文存储敏感信息，以及在可能的情况...
java使用Hex编码解码实现Aes加密解密功能示例
08-31
主要介绍了java使用Hex编码解码实现Aes加密解密功能,结合完整实例形式分析了Aes加密解密功能的定义与使用方法,需要的朋友可以参考下
很强的Java加密解密算法源码.zip
09-09
Java加密解密技术在软件开发中扮演着至关重要的角色，特别是在数据安全领域。3DES（Triple Data Encryption Standard）是一种常见的加密算法，它基于DES（Data Encryption Standard）并对其进行了加强，提高了安全性...
Java实现的AES256加密解密功能示例
08-31
以下是对Java实现AES256加密解密功能的详细解析： 1. **密钥生成**： 在提供的代码中，`initkey()` 方法使用`KeyGenerator`类生成AES256密钥。`KeyGenerator.getInstance(KEY_ALGORITHM, "BC")`初始化一个密钥生成...
Java加密解密
04-23
本文将深入探讨Java中的加密解密技术，基于提供的文件`PasswordUtil.java`和`DecryptAndEncryptUtil.java`，我们可以推测这两个文件包含了用于密码处理和数据加解密的实用工具类。 首先，Java提供了内置的`java....
Java中MessageDigest来实现数据加密的方法
08-19
主要介绍了Java中MessageDigest来实现数据加密的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java 实现 AES 加密和解密完整示例
蜗牛的博客
05-12 2万+
AES，全称为 Advanced Encryption Standard，是一种分组密码算法，用于保护敏感数据的传输和存储。AES 分为 128 位和 256 位两种密钥长度，可以对数据进行加密和解密，保证数据的安全性和完整性。AES 主要应用于电子商务、移动支付、网络安全等领域，被广泛运用于现代社会的各个方面。AES 算法被设计为高度安全，可以在理论上保证其分组密码的安全性。然而，由于其复杂性和密钥长度，AES 算法的实现和应用也具有一定的技术难度。
Java：MessageDigest&Base64类的解析与使用
m0_57042151的博客
12-06 749
在进行JavaWeb项目开发时，尤其是在实现登录/注册功能时，处于安全性考虑，经常需要将前端提交的用户密码信息做加密处理之后再存储到数据库中。而相对经常听到的加密算法是md5算法，那么，什么是MD5算法呢？MD5算法，全称为：MD5信息摘要算法（MD5 Message-Digest Algorithm），是一种被广泛应用的密码散列函数/加密散列函数。而作为散列函数之一的加密散列函数（Cryptographic Hash Function），是一种单向函数，类似于Vue中的单向数据流的概念，也即：极其难以由散
Java中字符串如何进行加密和解密
我点评的博客
05-25 7503
SHA1也是一种常见的加密算法，它可以将任意长度的字符串加密成一个固定长度（160位）的字符串。AES是一种高级加密标准，它可以将任意长度的字符串加密成一个固定长度（128位、192位或256位）的字符串。MD5是一种常见的加密算法，它可以将任意长度的字符串加密成一个固定长度（128位）的字符串。解密算法是将加密后的字符串还原成原始字符串的算法。由于SHA1算法是不可逆的，所以在Java中不提供SHA1的解密算法。由于MD5算法是不可逆的，所以在Java中不提供MD5的解密算法。
Java加密与解密
热门推荐
ThinkStu的博客
08-15 5万+
加密方式主要有3种，摘要加密、对称加密与非对称加密。
Java中常用的加密与解密
Lemon
12-23 7774
一、对称加密与非对称加密 1、对称加密 2、非对称加密 3、对称加密与非对称加密的区别
Base64
dazhi7898的博客
05-31 200
package com.ecton; import java.security.interfaces.RSAPublicKey; public final class Base64 { static private final int BASELENGTH = 128; static private final int LOO...
带界面的AES算法Java实现.pdf
05-28
带界面的AES算法Java实现.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值