常见加密工具类Base64、DES、AES、RSA、MD5汇总

最新推荐文章于 2024-04-14 17:27:40 发布
最新推荐文章于 2024-04-14 17:27:40 发布
阅读量1.3k 收藏 8
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011047968/article/details/104282684
版权

文章目录

引言

项目中经常会用到Base64、DES、AES、RSA、MD5几种加解密方式，每次都要去网上搜索半天，今天索性一次性把他们都汇总起来，以便记忆查找。
JDK版本：1.8.0_45
代码位置：com.leo.demo.encodetest
源码地址：https://gitee.com/leo825/sortalgorithm-demos.git

1、Base64加密

Base64编码，是我们程序开发中经常使用到的编码方法。它是一种基于用64个可打印字符来表示二进制数据的表示方法。它通常用作存储、传输一些二进制数据编码方法。

package com.leo.demo.encodetest;

import java.util.Base64;

/**
 * @ClassName: Base64Util
 * @Description: Base64编码，是我们程序开发中经常使用到的编码方法。它是一种基于用64个可打印字符来表示二进制数据的表示方法
 * @Author: leo825
 * @Date: 2020-02-12 17:32
 * @Version: 1.0
 */
public class Base64Util {

    private static final String CHARSET_UTF_8 = "UTF-8";

    /**
     * 使用base64加密
     *
     * @param content
     * @return
     */
    public static String encryptData(String content) throws Exception {
        return Base64.getEncoder().encodeToString(content.getBytes(CHARSET_UTF_8));
    }

    /**
     * 使用base64解密
     *
     * @param encryptData
     * @return
     */
    public static String decodeDate(String encryptData) throws Exception {
        return new String(Base64.getDecoder().decode(encryptData.getBytes()), CHARSET_UTF_8);
    }

    public static void main(String[] args) throws Exception {
        String str = "hello world, base64";
        System.out.println("原字符串：" + str);
        String encodeStr = encryptData(str);
        System.out.println("base64加密后：" + encodeStr);
        System.out.println("base64解密后：" + decodeDate(encodeStr));
    }
}

打印结果如下：

原字符串：hello world, base64
base64加密后：aGVsbG8gd29ybGQsIGJhc2U2NA==
base64解密后：hello world, base64
2、DES加密

DES是一个分组加密算法，它以64位为分组对数据加密。64位一组的明文从算法的一端输入，64位的密文从另一端输出，特点是数据加密标准，速度快，适用于加密大量数据的场合。**DES是一种对称加密算法，对称加密就是加解密秘钥是一样一样的。

package com.leo.demo.encodetest;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * @ClassName: DESUtil
 * @Description: DES加密
 * DES是对称性加密里面常见一种，全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。
 * 密钥长度是64位(bit)，超过位数密钥被忽略。所谓对称性加密，加密和解密密钥相同。
 * 对称性加密一般会按照固定长度，把待加密字符串分成块。不足一整块或者刚好最后有特殊填充字符
 * @Author: leo825
 * @Date: 2020-02-12 10:02
 * @Version: 1.0
 */
public class DESUtil {

    private static Key key;
    private static final String PRIVATE_KEY = "f573a9b0";

    static {
        try {
            KeyGenerator generator = KeyGenerator.getInstance("DES");
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(PRIVATE_KEY.getBytes());
            generator.init(secureRandom);
            key = generator.generateKey();
            generator = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加密，返回BASE64的加密字符串
     * @param str
     * @return
     */
    public static String getEncryptString(String str) throws Exception {
        byte[] strBytes = str.getBytes("UTF-8");
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptStrBytes = cipher.doFinal(strBytes);
        return Base64.getEncoder().encodeToString(encryptStrBytes);
    }

    /**
     * 对BASE64加密字符串进行解密
     * @param str
     * @return
     */
    public static String getDecryptString(String str) throws Exception {
        byte[] strBytes = Base64.getDecoder().decode(str);
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] encryptStrBytes = cipher.doFinal(strBytes);
        return new String(encryptStrBytes, "UTF-8");
    }

    public static void main(String[] args) throws Exception {
        String name = "root";
        String password = "1qaz!QAZ";
        String encryname = getEncryptString(name);
        String encrypassword = getEncryptString(password);
        System.out.println("加密：" + encryname);
        System.out.println("加密：" + encrypassword);

        System.out.println("解密：" + getDecryptString(encryname));
        System.out.println("解密：" + getDecryptString(encrypassword));
    }
}

打印结果如下：

加密：Lk/2YIL4N+c=
加密：SatR2mGfn3WncqRUHpmsrQ==
解密：root
解密：1qaz!QAZ
3、AES加密

AES高级加密标准(,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。**AES也是一种对称加密算法，对称加密就是加解密秘钥是一样一样的。**详情参考百度百科AES

package com.leo.demo.encodetest;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
/**
 * @ClassName: AESUtil
 * @Description: AES 本身就是为了取代 DES 的，AES 具有更好的 安全性、效率 和 灵活性
 * @Author: leo825
 * @Date: 2020-02-12 09:46
 * @Version: 1.0
 */
public class AESUtil {

    /*
     * 加密（对外暴露）
     */
    public static String encryptData(String privateKey, String content) throws Exception {
        KeyGenerator keygen = getKeyGenerator(privateKey);
        SecretKey key = new SecretKeySpec(keygen.generateKey().getEncoded(), "AES");
        return Base64.getEncoder().encodeToString(encrypt(key, content.getBytes("UTF-8")));
    }

    /*
     * 解密（对外暴露）
     */
    public static String decryptData(String privateKey, String content) throws Exception {
        KeyGenerator keygen = getKeyGenerator(privateKey);
        SecretKey key = new SecretKeySpec(keygen.generateKey().getEncoded(), "AES");
        return new String(decrypt(key, Base64.getDecoder().decode(content)), "UTF-8");
    }

    private static KeyGenerator getKeyGenerator(String privateKey) throws NoSuchAlgorithmException {
        KeyGenerator keygen = KeyGenerator.getInstance("AES");
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(privateKey.getBytes());
        keygen.init(128, secureRandom);
        return keygen;
    }

    private static byte[] encrypt(Key key, byte[] srcBytes) {
        if (key != null) {
            try {
                // Cipher负责完成加密或解密工作，基于AES
                Cipher cipher = Cipher.getInstance("AES");
                // 对Cipher对象进行初始化
                cipher.init(Cipher.ENCRYPT_MODE, key);
                // 加密，保存并返回
                return cipher.doFinal(srcBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private static byte[] decrypt(Key key, byte[] encBytes) {
        if (key != null) {
            try {
                Cipher cipher = Cipher.getInstance("AES");
                //对Cipher对象进行初始化
                cipher.init(Cipher.DECRYPT_MODE, key);
                //解密
                return cipher.doFinal(encBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    public static void main(String[] args) throws Exception {
        String privateKey = "ABC";
        String content = "ASD456";
        String m = encryptData(privateKey, content);
        System.out.println("要加密的内容为：：" + content);
        System.out.println("根据私钥：" + privateKey + "，加密后的密文是：" + m);
        System.out.println("根据私钥：" + privateKey + "，解密后的明文是：" + decryptData(privateKey, m));
    }

}

运行结果：

要加密的内容为：：ASD456
根据私钥：ABC，加密后的密文是：6vLE6e1f//pq9e+ZmczfxQ==
根据私钥：ABC，解密后的明文是：ASD456
4、RSA加密

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。通常个人保存私钥，公钥是公开的（可能同时多人持有）。

package com.leo.demo.encodetest;

import org.apache.commons.lang3.StringUtils;

import javax.crypto.Cipher;
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;
/**
 * @ClassName: RSAUtil
 * @Description:
 *  RSA 加密算法是目前最有影响力的 公钥加密算法，并且被普遍认为是目前 最优秀的公钥方案 之一。
 *  RSA 是第一个能同时用于 加密 和 数字签名 的算法，它能够 抵抗 到目前为止已知的 所有密码攻击，已被 ISO 推荐为公钥数据加密标准。
 * @Author: leo825
 * @Date: 2020-02-12 09:35
 * @Version: 1.0
 */

public class RSAUtil {

    /**
     * 加密（对外暴露）
     * 如果使用 公钥 对数据 进行加密，只有用对应的 私钥 才能 进行解密。
     * 如果使用 私钥 对数据 进行加密，只有用对应的 公钥 才能 进行解密。
     *
     * @param keyStr
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptData(String keyStr, String data, Boolean isPublicKey) throws Exception {
        if (StringUtils.isEmpty(keyStr)) {
            return "";
        }
        return encryptBASE64(encrypt(getKey(keyStr, isPublicKey), data.getBytes()));
    }

    /**
     * 解密（对外暴露）
     * 如果使用 公钥 对数据 进行加密，只有用对应的 私钥 才能 进行解密。
     * 如果使用 私钥 对数据 进行加密，只有用对应的 公钥 才能 进行解密。
     *
     * @param keyStr
     * @param data
     * @return
     * @throws Exception
     */
    public static String decryptData(String keyStr, String data, Boolean isPublicKey) throws Exception {
        if (StringUtils.isEmpty(keyStr)) {
            return "";
        }
        return new String(decrypt(getKey(keyStr, isPublicKey), decryptBASE64(data)), "UTF-8");
    }

    /**
     * 加密
     *
     * @param key
     * @param srcBytes
     * @return
     */
    private static byte[] encrypt(Key key, byte[] srcBytes) {
        if (key != null) {
            try {
                //Cipher负责完成加密或解密工作，基于RSA
                Cipher cipher = Cipher.getInstance("RSA");
                //对Cipher对象进行初始化
                cipher.init(Cipher.ENCRYPT_MODE, key);
                //加密，并返回
                return cipher.doFinal(srcBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 解密
     *
     * @param key
     * @param encBytes
     * @return
     */
    private static byte[] decrypt(Key key, byte[] encBytes) {
        if (key != null) {
            try {
                Cipher cipher = Cipher.getInstance("RSA");
                //对Cipher对象进行初始化
                cipher.init(Cipher.DECRYPT_MODE, key);
                //解密并返回结果
                return cipher.doFinal(encBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 根据key获取公有或者私有key对象
     *
     * @param keyStr
     * @param isPublicKey
     * @return
     * @throws Exception
     */
    private static Key getKey(String keyStr, Boolean isPublicKey) throws Exception {
        if (isPublicKey) {
            return getPublicKey(keyStr);
        } else {
            return getPrivateKey(keyStr);
        }
    }

    /**
     * 根据公有key获取公有key对象
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static RSAPublicKey getPublicKey(String key) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(key);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    }

    /**
     * 根据私有key获取私有对象
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static RSAPrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    }

    /**
     * 获取公有/私有Key
     *
     * @return
     */
    private static KeyPair getRSAKey() {
        KeyPair keyPair = null;
        try {
            //生成公钥和私钥对，基于RSA算法生成对象
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            //初始化密钥对生成器，密钥大小为1024位
            keyPairGen.initialize(1024);
            //生成一个密钥对，保存在keyPair中
            keyPair = keyPairGen.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyPair;
    }

    /**
     * 对字符串进行BASE64Decoder
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static byte[] decryptBASE64(String key) {
        return Base64.getDecoder().decode(key);
    }

    /**
     * 对字节数组进行BASE64Encoder
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static String encryptBASE64(byte[] key) {
        return Base64.getEncoder().encodeToString(key);
    }

    public static void main(String[] args) {
        // 生成的一对key保存好
        try {
            //得到私钥和公钥
            KeyPair keyPair = getRSAKey();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

            String pubKey = encryptBASE64(publicKey.getEncoded());
            String priKey = encryptBASE64(privateKey.getEncoded());
            System.out.println("公钥：" + pubKey);
            System.out.println("私钥：" + priKey);

            // 测试
            String message = "QWERDF";

            System.out.println("明文：" + message);
            String jiami = encryptData(pubKey, message, true);
            System.out.println("公钥加密后：" + jiami);
            String jiemi = decryptData(priKey, jiami, false);
            System.out.println("用私钥解密后的结果是:" + jiemi);

            jiami = encryptData(priKey, message, false);
            System.out.println("私钥加密后：" + jiami);
            jiemi = decryptData(pubKey, jiami, true);
            System.out.println("用公钥解密后的结果是:" + jiemi);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

打印结果如下：

公钥：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCUK5sCqFJblXMMUzkPkC7vDmo7S51yIpMlkKDB67eVYh7M7sbPI9MBB3jzlscL08rYpnB7xA8zq5PZZHsALeAa+PU4Kxfkl1shnji11HDIzVOE53sArBqeh/IWScIkM5QY/Me3jXsqg+j8l5XmIVQSqmA+Bj19Vw9LJ9TLm50xLwIDAQAB
私钥：MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJQrmwKoUluVcwxTOQ+QLu8OajtLnXIikyWQoMHrt5ViHszuxs8j0wEHePOWxwvTytimcHvEDzOrk9lkewAt4Br49TgrF+SXWyGeOLXUcMjNU4TnewCsGp6H8hZJwiQzlBj8x7eNeyqD6PyXleYhVBKqYD4GPX1XD0sn1MubnTEvAgMBAAECgYAxi2sntlTjntN7eZCI7bNj6DQJY71f3sPJOdUnQsR+RPL7n5QGy3nQzEjbWr1v7P/U9cKDAAn9QxALDxg59R0MI46xAi4NZkP6/p/fA2qTlXFxyBkCvKoOjyMMeH/l7YM90qTg5NB2M+LkOXswrkKj9JAh4zZ7raE6RRdyKu3e4QJBAOhbpRHEDwOX/xa7HDFUWZMWCzMUw1k06QqMJZyrJPfQjH9KOph6r86T+6WxlpC4FfIAWWaahXEzrakaPWnZB0kCQQCjPxQ4z1F5HHDin6tPB1M2uTh0R3WWmNmqtKiChCYePcwco1HmkgaJxMarqpOJj7H2600XiV/R5PZGVMpORRy3AkA527Aj110huPR09YyUn/taC9AoHRBzoyAwVyt6codXCeAiRhqHI22pk+HCpZDnYl9cjke0q990i7i/deA6/ia5AkBNJK/vsLj1nKUT0xRnQjTmtVyiRmqhAhZKfxjqpHxG6jkch2lapkMEs8KWuQMDjK4y2zsRFk/7plFjJwp7Nlm9AkEAjj3xaxd8UIYOZpTq5mv0yyPmXE1zsMIjKQkmXXOma5WZElo7130b70Vj463150C0X/66upP+i9r6NS/ijwkmrg==
明文：QWERDF
公钥加密后：gKeXQIcZf+8u48DLoSOCbwBHGia9hkrvjh+AWiX7GB1pbox6us+ysYfeVNt+QDL39Fzwy/sMMFGsvSxnxR+aZuWWcyYO6C1vsbqgfk/gQ/WnwZzS23w5qEcq1LI2AEwVn3j3T1gQvDGmWgw4D8f3srPi9WgB3YbVNM6TBRtXgyE=
用私钥解密后的结果是:QWERDF
私钥加密后：ACgPe2wS94ttqivgPRGn5sLQIKhim+xmCcYyTBxxB9QsNkNFHAMHF0pt/WhUpEfPiKp4hC3XvOqhGZwLeqlFkGj86bl+WH55jadntDWYIbC0ylMpWlNz7Djdhp+g2mt2+ZnZ8JrNXQYyQkm+AjrrfWyVYccSf8+SVveVaJ548xw=
用公钥解密后的结果是:QWERDF
5、MD5加密

主要是对于密码的加密，MD5加密是不可逆的，加密后无法解密，直接将加密后的数据作为密码；这样就算得到用户密码的MD5值，也无法获取用户的密码，就算是管理员也无法得知用户密码。

package com.leo.demo.encodetest;

import java.security.MessageDigest;

/**
 * @ClassName: MD5Util
 * @Description: MD5加密
 * MD5，即消息摘要算法（英语：MD5 Message-Digest Algorithm）。
 * 是一种被广泛使用的密码散列函数，将数据（如一段文字）运算变为另一固定长度值，
 * 是散列算法的基础原理，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致
 * @Author: leo825
 * @Date: 2020-02-12 18:02
 * @Version: 1.0
 */
public class MD5Util {

    private static final String CHARSET_UTF_8 = "UTF-8";

    private static final String hexDigIts[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};

    /**
     * MD5加密
     *
     * @param origin      字符
     * @param charsetname 编码
     * @return
     */
    public static String encodeData(String origin, String charsetname) {
        String resultString = null;
        try {
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (null == charsetname || "".equals(charsetname)) {
                resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
            } else {
                resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
            }
        } catch (Exception e) {
        }
        return resultString;
    }

    /**
     * 默认使用的utf-8进行编码,32位小写
     * @param origin
     * @return
     */
    public static String encodeData32(String origin) {
        return encodeData(origin, CHARSET_UTF_8);
    }

    /**
     * 默认使用的utf-8进行编码,32位大写
     * @param origin
     * @return
     */
    public static String encodeData32UpperCase(String origin){
        return encodeData(origin, CHARSET_UTF_8).toUpperCase();
    }

    /**
     * 默认使用的utf-8进行编码,16位小写
     * @param origin
     * @return
     */
    public static String encodeData16(String origin){
        return encodeData(origin, CHARSET_UTF_8).substring(8,24);
    }

    /**
     * 默认使用的utf-8进行编码,16位大写
     * @param origin
     * @return
     */
    public static String encodeData16UpperCase(String origin){
        return encodeData(origin, CHARSET_UTF_8).substring(8, 24).toUpperCase();
    }


    private static String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }

    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0) {
            n += 256;
        }
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigIts[d1] + hexDigIts[d2];
    }


    public static void main(String[] args) {
        String username = "张三";
        System.out.println(encodeData16(username));
        System.out.println(encodeData16UpperCase(username));
        System.out.println(encodeData32(username));
        System.out.println(encodeData32UpperCase(username));
    }


}

打印结果如下：

a314529aaa0fbe95
A314529AAA0FBE95
615db57aa314529aaa0fbe95b3e95bd3
615DB57AA314529AAA0FBE95B3E95BD3
leo825...
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
常用加密算法工具（计算器）
10-27
加密算法计算器，支持DES 3DES CBC MAC SM2 SM3 SM4 MD5 SHA等 CPU卡，加密算法，java卡类行开发者助手！
android studio JNI RSA DES AES base64 MD5 加解密.rar
09-24
本资源提供了在Android Studio项目中使用JNI实现RSA、DES、AES以及Base64和MD5的示例。 1. **RSA**: RSA是一种非对称加密算法，它基于两个密钥——公钥和私钥。公钥可以公开，用于加密数据；而私钥必须保密，用于...
springsecurity中常见的加密工具类
qq_44113347的博客
04-01 381
Spring Security提供了很多加密工具类来保护用户密码等敏感信息的安全，包括对称加密算法、非对称加密算法、哈希算法等。这些工具类可以帮助开发者在用户密码存储、网络传输等方面提供更安全的保护。还有些不常用的就编写了。
java 实现RSA+sha256(校验值)+base64转码 加密
最新发布
qq_42208194的博客
04-14 519
算法是一种非对称加解密算法。服务方生成一对 RSA 密钥，即公钥 + 私钥，将公钥提供给调用方，调用方使用公钥对数据进行加密后，服务方根据私钥进行解密。我们要实现对数据加密，先使用sha256对数据算出哈希值，用于验证数据的完整性和真实性，保证不会被篡改，再放到RSA加密，最后通过base64转码。base64 工具类。
自己的加密....类似MIME:base64
云梦泽
07-13 121
程序下载地址:http://vipexxe.googlepages.com/mymime.jar用存在的KEY文件进行加密,请运行: java -jar mymime.jar + Key 明文文件自己产生新的KEY文件,并进行加密,运行方法: java -jar mymime.jar ++ Key 明文文件解密文件时,使用: java -jar mymime.jar - Key  密文文件...
base64加密 工具类
qq_40177359的博客
02-21 326
import org.apache.commons.codec.binary.Base64; import java.io.UnsupportedEncodingException; public class Base64UtilJm { /** * 解密 * * @param data * @return * @author j...
BASE64 加密工具类
chenzhenguo
05-22 857
import java.io.IOException; import java.io.InputStream; /** * Description: * 该类包装了 sun.misc.BASE64Encoder 和 sun.misc.BASE64Decoder 的常用方法。 * * For example: * * * @author guowd * @version 1.00 ...
base64加密工具类
任意门的博客
01-25 122
package com.ssish.wxmall.common.data; import java.io.ByteArrayOutputStream; import java.util.Random; /** * base64 * @author zhangkun 2019-01-02 21:52:00 * */ public class Base64 { private s...
Vue-常用加密(MD5,DES,SHA256,BASE64,SHA1,RSA)
11-29
在 Vue 中，常见的加密算法包括 MD5、DES、SHA256、BASE64、SHA1、RSA 等。BASE64 只是一种编码格式，并不是加密算法，但常用于在 HTTP 环境下传递较长的标识信息。 加密算法的选择需要根据实际情况进行选择，考虑...
Delphi AES DES MD5 RSA BASE64等加密算法源码实例集.rar
07-10
Delphi加密算法集，包括了Delphi AES DES MD5 RSA BASE64 2DES 3DES Blowfish CRC32-Static SHA等 常用的加密算法用法实例，比较不错的Delphi加密实例代码了，浅显易懂而且实用的常见加密算法实例，包括字符串和文件...
Base64加密算法（工具类）
08-06
java代码。支持加密与解密，Base64加密算法
Base64加密解密工具类
05-02
java开发使用base64进行加密解密，开发人员只需调用其中方法即可完成加密解密操作！
DES，AES，RSA，MD5加密
12-07
支持 DES，AES，RSA，MD5加密，工具类，导入即用。欢迎下载
Base64工具类（加密、解密 ）以及MD5加密
12-28
加解密工具集 对字符串做BASE64加密 解密 MD5加密 解密 DES加密 DES解密 AES加密 AES解密
base64加密解密工具
04-09
JS中引入base64可以对json进行加密，服务器端可以解析出标准json格式
android studio JNI RSA DES AES base64 MD5 加解密
12-08
采用C++ 和android studio 编译，导入即可使用，较为简单。实现了 RSA DES AES MD5 BASE64 在native 层加解密。demo是本人花了很多花心血完成。 博客：http://download.csdn.net/detail/gao1040841994/9630750
Base64加密工具类
weixin_51001722的博客
06-03 225
【代码】Base64加密工具类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leo825...

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值