java token加密解密算法_java基于Des对称加密算法实现的加密与解密功能详解

最新推荐文章于 2023-12-09 17:34:43 发布
最新推荐文章于 2023-12-09 17:34:43 发布
阅读量670 收藏
点赞数
文章标签： java token加密解密算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_29621655/article/details/114137333
版权
本文详细介绍了如何在Java中使用DES对称加密算法进行加密和解密。通过示例代码展示了如何利用`sun.misc.BASE64Decoder`和`sun.misc.BASE64Encoder`以及`org.apache.commons.codec.binary.Base64`进行编码解码。文章还探讨了在编码解码过程中是否需要UTF-8或GBK编码的问题。
摘要由CSDN通过智能技术生成

本文实例讲述了java基于Des对称加密算法实现的加密与解密功能。分享给大家供大家参考，具体如下：

Des 加密相关类介绍：

SecureRandom  这个类是继承自java.util.Random 这个类

SecureRandom 这个类的构造器有三种，下面例举两种：

SecureRandom()构造一个实现默认随机数算法的安全随机数生成器 (RNG)。

SecureRandom(byte[] seed)构造一个实现默认随机数算法的安全随机数生成器 (RNG)。

DESKeySpec 这个类是用来使用原始秘钥来生成秘钥的秘钥内容

DESKeySpec 有两个构造函数：

DESKeySpec(byte[] key) 创建一个 DESKeySpec 对象，使用 key 中的前 8 个字节作为 DES 密钥的密钥内容。

DESKeySpec(byte[] key, int offset) 创建一个 DESKeySpec 对象，使用 key 中始于且包含 offset 的前 8 个字节作为 DES-EDE 密钥的密钥内容。

SecretKeyFactory ， 密钥工厂用来将密钥(类型 Key 的不透明加密密钥)转换为密钥规范(底层密钥材料的透明表示形式)，反之亦然。秘密密钥工厂只对秘密(对称)密钥进行操作。

SecretKey对象，秘钥对象，通过调用秘钥工厂的generateSecret(DESKeySpec deskeyspace) 方法来生成秘钥

Cipher 类为加密和解密提供密码功能，通过调用Cipher的getInstance("des") 来获取实例

Cipher 对象调用init() 方法进行对象的初始化，init() 方法的具体参数按照具体情况而定，有加密的也有解密的常量

最后调用Cipher的doFinal() 方法进行加密解密。

在这里请教大家一个问题，不管是第一种使用BASE64Encoder编码还是第二种org.apache.commons.codec.binary.Base64编码，在将String 转化为byte以及将byte转化为String 时需要 UTF-8/GBK 等编码来编码，解码吗？

一、使用了 sun.misc.BASE64Decoder 和BASE64Encoder 进行解码，编码

package com.soufun.com;

import java.io.IOException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.util.Date;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

// 导入sun的64位编码

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

/**

*@author WHD

*

*即使导入sun.misc这个架包也会报错，这时首先把你的JRE架包移除再导入一次就可以了

*/

public class DesUtil {

// 定义加密方式

private final static String DES = "DES";

private final static String UTF8="GBK";

static SecretKeyFactory keyFactory = null;

static {

try {

keyFactory=SecretKeyFactory.getInstance("DES");

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public static void main(String[] args) throws Exception {

long begin=new Date().getTime();

String data = "aaades加密测试";

// 注意：DES加密和解密过程中，密钥长度都必须是8的倍数

String key = "qazwsxed";

System.err.println(encrypt(data, key));

System.err.println(decrypt(encrypt(data, key), key));

long end =new Date().getTime();

System.out.println(end-begin);

}

/**

* Description 根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

public static String encrypt(String data, String key) throws Exception {

// 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以

byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes(UTF8));

//注意：在加密和解密的时候使用sun的BASE64Encoder()进行编码和解码不然会有乱码

//网上查看了很多实例，都没有编码和解码，也说没有乱码问题，而我这里出现了乱码，所以使用BASE64Encoder()进行了编码解码

String strs = new BASE64Encoder().encode(bt);

return strs;

}

/**

* Description 根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws IOException

* @throws Exception

*/

public static String decrypt(String data, String key) throws IOException,

Exception {

if (data == null)

return null;

//注意：在加密和解密的时候使用sun的BASE64Encoder()进行编码和解码不然会有乱码

BASE64Decoder decoder = new BASE64Decoder();

byte[] buf = decoder.decodeBuffer(data);

byte[] bt = decrypt(buf,key.getBytes());

return new String(bt,UTF8);

}

/**

* Description 根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

private static byte[] encrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容

DESKeySpec dks = new DESKeySpec(key);

// 密钥工厂用来将密钥(类型 Key 的不透明加密密钥)转换为密钥规范(底层密钥材料的透明表示形式)，反之亦然。秘密密钥工厂只对秘密(对称)密钥进行操作。

// 这里改为使用单例模式

//SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

//根据提供的密钥规范(密钥材料)生成 SecretKey(秘钥) 对象。

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher对象实际完成加密操作,此类为加密和解密提供密码功能

Cipher cipher = Cipher.getInstance(DES);

// 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。

cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

//正式执行加密操作

return cipher.doFinal(data);

}

/**

* Description 根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

private static byte[] decrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容

DESKeySpec dks = new DESKeySpec(key);

// 密钥工厂用来将密钥(类型 Key 的不透明加密密钥)转换为密钥规范(底层密钥材料的透明表示形式)，反之亦然。秘密密钥工厂只对秘密(对称)密钥进行操作。

// 这里改为使用单例模式

//SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

//根据提供的密钥规范(密钥材料)生成 SecretKey(秘钥)对象。

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher类为加密和解密提供密码功能

Cipher cipher = Cipher.getInstance(DES);

// DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。

cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

// 正式进行解密操作

return cipher.doFinal(data);

}

}

二、使用org.apache.commons.codec.binary.Base64 进行解码，编码

package com.soufun.com;

import java.io.IOException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.util.Date;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import org.apache.commons.codec.binary.Base64;

/**

*@author WHD

*

*/

public class DesUtil {

// 定义加密方式

private final static String DES = "DES";

private final static String UTF8="GBK";

static SecretKeyFactory keyFactory = null;

static {

try {

keyFactory=SecretKeyFactory.getInstance("DES");

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public static void main(String[] args) throws Exception {

long begin=new Date().getTime();

String data = "aaades加密测试";

// 注意：DES加密和解密过程中，密钥长度都必须是8的倍数

String key = "qazwsxed";

System.err.println(encrypt(data, key));

System.err.println(decrypt(encrypt(data, key), key));

long end =new Date().getTime();

System.out.println(end-begin);

}

/**

* Description 根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

public static String encrypt(String data, String key) throws Exception {

// 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以

byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes());

// 第一个使用了sun.misc.BASE64Encoder;进行了编码，但网上说使用org.apache.commons.codec.binary.Base64比较好所以拿来试试

String strs = Base64.encodeBase64String(bt);

return strs;

}

/**

* Description 根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws IOException

* @throws Exception

*/

public static String decrypt(String data, String key) throws IOException,

Exception {

if (data == null)

return null;

// 使用org.apache.commons.codec.binary.Base64解码

byte [] buf=Base64.decodeBase64(data);

byte[] bt = decrypt(buf,key.getBytes());

return new String(bt,UTF8);

}

/**

* Description 根据键值进行加密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

private static byte[] encrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容

DESKeySpec dks = new DESKeySpec(key);

// 密钥工厂用来将密钥(类型 Key 的不透明加密密钥)转换为密钥规范(底层密钥材料的透明表示形式)，反之亦然。秘密密钥工厂只对秘密(对称)密钥进行操作。

// 这里改为使用单例模式

//SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

//根据提供的密钥规范(密钥材料)生成 SecretKey(秘钥) 对象。

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher对象实际完成加密操作,此类为加密和解密提供密码功能

Cipher cipher = Cipher.getInstance(DES);

// 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。

cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

//正式执行加密操作

return cipher.doFinal(data);

}

/**

* Description 根据键值进行解密

* @param data

* @param key 加密键byte数组

* @return

* @throws Exception

*/

private static byte[] decrypt(byte[] data, byte[] key) throws Exception {

// 生成一个可信任的随机数源

SecureRandom sr = new SecureRandom();

// 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容

DESKeySpec dks = new DESKeySpec(key);

// 密钥工厂用来将密钥(类型 Key 的不透明加密密钥)转换为密钥规范(底层密钥材料的透明表示形式)，反之亦然。秘密密钥工厂只对秘密(对称)密钥进行操作。

// 这里改为使用单例模式

//SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

//根据提供的密钥规范(密钥材料)生成 SecretKey(秘钥)对象。

SecretKey securekey = keyFactory.generateSecret(dks);

// Cipher类为加密和解密提供密码功能

Cipher cipher = Cipher.getInstance(DES);

// DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。

cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

// 正式进行解密操作

return cipher.doFinal(data);

}

}

一、二中使用到的架包下载地址：

三、未使用任何编码，解码架包

package com.soufun.com;

import java.io.IOException;

import java.security.NoSuchAlgorithmException;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import javax.crypto.spec.IvParameterSpec;

/**

*@author WHD

*

*/

public class DESCrypt {

static SecretKeyFactory secretKeyFactory = null;

//Cipher 的“算法/模式/填充”

static final String CIPHER = "DES/CBC/PKCS5Padding";

static {

try {

// 在静态代码块中获取秘钥工程

secretKeyFactory = SecretKeyFactory.getInstance("DES");

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

}

// 定义常量 ，编码格式

private static final String UTF8 = "GBK";

/*

* 对象缓存的容器

*/

static abstract class Cache {

private final Map innerCache = new HashMap();

protected abstract Object createValue(Object key) throws Exception;

public Object get(Object key) throws Exception {

Object value;

synchronized (innerCache) {

value = innerCache.get(key);

if (value == null) {

value = new CreationPlaceholder();

innerCache.put(key, value);

}

}

if (value instanceof CreationPlaceholder) {

synchronized (value) {

CreationPlaceholder progress = (CreationPlaceholder) value;

if (progress.value == null) {

progress.value = createValue(key);

synchronized (innerCache) {

innerCache.put(key, progress.value);

}

}

return progress.value;

}

}

return value;

}

static final class CreationPlaceholder {

Object value;

}

}

/*

* hex->str & str->hex

*/

public static byte[] stringToHex(String ss) {

// 字符串转化we

byte digest[] = new byte[ss.length() / 2];

for (int i = 0; i < digest.length; i++) {

String byteString = ss.substring(2 * i, 2 * i + 2);

int byteValue = Integer.parseInt(byteString, 16);

digest[i] = (byte) byteValue;

}

return digest;

}

public static String hexToString(byte b[]) {

StringBuffer hexString = new StringBuffer();

for (int i = 0; i < b.length; i++) {

String plainText = Integer.toHexString(0xff & b[i]);

if (plainText.length() < 2) {

hexString.append("0");

}

hexString.append(plainText);

}

return hexString.toString();

}

private static byte[] _convertKeyIv(String text) throws IOException {

if (text.length() == 8) {

return text.getBytes(UTF8);

}

if (text.startsWith("0x") && text.length() == 32) {

byte[] result = new byte[8];

for (int i = 0; i < text.length(); i += 2) {

if (text.charAt(i++) == '0' && text.charAt(i++) == 'x') {

try {

result[i / 4] = (byte) Integer.parseInt(

text.substring(i, i + 2), 16);

} catch (Exception e) {

throw new IOException("TXT '" + text + "' is invalid!");

}

}

}

return result;

}

throw new IOException("TXT '" + text + "' is invalid!");

}

/*

* SecretKey & IvParameterSpec的缓存

*/

private static Cache SecretKeySpecs = new Cache() {

protected Object createValue(Object key) throws Exception {

SecretKey secretKeyObj = null;

try {

secretKeyObj = secretKeyFactory.generateSecret(new DESKeySpec(

_convertKeyIv((String) key)));

} catch (Exception e) {

e.printStackTrace();

}

return secretKeyObj;

}

};

private static Cache IvParamSpecs = new Cache() {

protected Object createValue(Object key) throws Exception {

IvParameterSpec ivObj = null;

ivObj = new IvParameterSpec(_convertKeyIv((String) key));

return ivObj;

}

};

/*

* 加密&解密

*/

public static String encrypt(String text, String authKey, String authIv) {

SecretKey secretKeyObj = null;

IvParameterSpec ivObj = null;

try {

secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);

ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);

} catch (Exception e) {

e.printStackTrace();

}

byte[] data = null;

try {

data = text.getBytes(UTF8);

} catch (Exception e) {

e.printStackTrace();

}

byte[] authToken = null;

try {

authToken = encrypt(data, secretKeyObj, ivObj);

} catch (Exception e) {

e.printStackTrace();

}

return hexToString(authToken);

}

public static byte[] encrypt(byte[] data, SecretKey secretKey,

IvParameterSpec iv) throws Exception {

Cipher cipher = Cipher.getInstance(CIPHER);

cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);

return cipher.doFinal(data);

}

public static String decrypt(String hexString, String authKey, String authIv)

throws Exception {

SecretKey secretKeyObj = null;

IvParameterSpec ivObj = null;

try {

secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);

ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);

} catch (Exception e) {

e.printStackTrace();

}

String text = decrypt(hexString, secretKeyObj, ivObj);

return text;

}

public static String decrypt(String message, SecretKey secretKey,

IvParameterSpec iv) throws Exception {

byte[] data = stringToHex(message);

return decrypt(data, secretKey, iv);

}

public static String decrypt(byte[] data, SecretKey secretKey,

IvParameterSpec iv) throws Exception {

Cipher cipher = Cipher.getInstance(CIPHER);

cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);

byte[] retByte = cipher.doFinal(data);

return new String(retByte);

}

public static void main(String[] args) throws Exception {

long begin= new Date().getTime();

String authKey = "w8f3k9c2";

String authIv = "w8f3k9c2";

String text = "aaades加密测试";

// 140CB412BA03869F

// 140cb412ba03869f

// 对原文进行加密

String encryptedText = encrypt(text, authKey, authIv);

System.out.println("encryptedText:" + encryptedText);

// 对密文进行还原

String plainText = decrypt(encryptedText, authKey, authIv);

System.out.println("plainText:" + plainText);

//2a329740ce15f549be64190b183a5be2

long end =new Date().getTime();

System.out.println(end-begin);

}

}

PS：关于加密解密感兴趣的朋友还可以参考本站在线工具：

在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密工具：http://tools.jb51.net/password/hash_md5_sha

希望本文所述对大家java程序设计有所帮助。

刘文龙PhD
关注
Java与Winform进行AES加解密数据传输的工具类与对应关系和示例
BADAO_LIUMANG_QIZHI的博客
03-06 717
上面讲的Java与安卓进行数据传输时使用AES加解密的示例工具类。如果Java需要与其他第三方平台比如Winform程序进行数据传递时也需要数据加解密。
加密解密之Token令牌
sinat_36618660的博客
03-19 5062
一、base64 (1). base64加密解密方法图示 方法 作用 参数 返回值 b64encode 将输入的参数转化为base64规则的串 预加密的明文，类型为bytes；例：b‘steve Jobs’ base64对应编码的密文，类型为bytes；例:b’c3RldmUgSm9icw==’ b64decode 将base64串解密回明文 base64密文，类型为bytes...
java token加密解密算法_JavaToken认证JWT加密
weixin_39575212的博客
02-13 1836
支持跨域访问，将token置于请求头中，而cookie是不支持跨域访问的；JWT：JSON Web Token，其实token就是一段字符串，由三部分组成：第一部分我们称它为头部(header),第二部分我们称其为载荷(payload)，第三部分是签证(signature)。Token 是在服务端产生的。如果前端使用用户名/密码向服务端请求认证，服务端认证成功，那么在服务端会返回 Token ...
java token加密解密算法_java加密解密
weixin_39965673的博客
02-13 781
java加密解密public class MD5Util {/*** @param args*/public static void main(String[] args) {System.out.println(decrypt("137%128%143%145%124%144%135%143%76%"));System.out.println(encrypt("frontdev"));}/***...
Token的加密和解密
Mr_Dracy的博客
05-13 3931
package com.bike.trainer.util; import com.bike.trainer.entity.User; import io.jsonwebtoken.Claims; import io.jsonwebtoken.JwtBuilder; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import java.util.Date; import java.util.HashMap;
java token 加密解密_Token的解密和加密
weixin_39816062的博客
02-28 2102
首先引入pom依赖com.auth0java-jwt3.4.0加密Tokenimport java.util.Calendar;import java.util.Date;import com.auth0.jwt.JWT;import com.auth0.jwt.algorithms.Algorithm;import com.baidu.websocket.core.constans.SysCfg...
jwttoken解码_java使用jwt实现token创建加密解码操作
weixin_29243279的博客
01-27 2574
背景：因为现在要进行前后端分离开发，会产生跨域问题 ，所以要解决 两个问题 1、跨域名访问 2、使用 token令牌操作二、使用jwt解决 token问题：步骤：1)、pom.xml文件中导入com.google.code.gsongson2.6.2com.auth0java-jwt3.1.0io.jsonwebtokenjjwt0.7.02)、创建 JwtUtil.java Cons...
Java_加密解密之对称加密算法DES
07-30
Java_加密解密之对称加密算法DES
Java安全知识点详解：加密、认证、防护和漏洞扫描
06-19
对称加密，如DES和AES，使用相同的密钥进行加解密，适合大量数据的快速处理，但密钥管理和分发是个挑战。非对称加密，如RSA和DSA，则使用公钥加密、私钥解密，提供更好的安全性，但计算速度较慢。数字签名则用于验证...
JAVA加密解密DES对称加密算法
Thinking
08-01 552
文章来源：http://blog.csdn.net/forlong401/article/details/7192980 http://blog.csdn.net/chinaguangzhou000000/article/details/6697481 下面用DES对称加密算法（设定一个密钥，然后对所有的数据进行加密）来简单举个例子。 首先，生成一个密钥KEY。 我把它保存
Java 加密解密之对称加密算法DES
忘掉地平线
05-27 1525
博客分类： Java Javajava des Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法（MD5 SHA MAC） Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法DESede Java 加密解密之对称加密算法AES Java 加密解密之对称加密算法PBEJava 加
Token的解密和加密
怪只怪满眼尽是人间烟火
07-12 7518
首先引入pom依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.4.0</version> </dependency> 加密Token ...
认证码Token加密解密代码
10-23
认证码Token加密解密代码 若有用你下载便是
加密算法 — — 对token进行非对称加密【RSA】
weixin_45565886的博客
08-29 3229
加密算法 — — 对token进行非对称加密【RSA】
java中Token加解密的3种方法
最新发布
weixin_65399034的博客
12-09 1564
java中三种解密（对称加密算法，非对称加密算法，HMAC加密方法）
网络数据加密与解密技术详解
加密算法和密钥是数据加密的核心，加密算法通过一系列的数学运算将明文（原始数据）转换为密文（加密后的数据），密钥用于控制加密算法的执行过程。只有拥有正确的密钥才能解密密文恢复为明文。 ### 1.2 对称加密与...
Token 常用的加解密算法
IT徐师兄
05-19 5370
常用的 Token 加密算法包括对称加密算法和非对称加密算法。对称加密算法使用相同的密钥来进行加密和解密，加密速度快，但是密钥传输和管理较为复杂。非对称加密算法使用一对公钥和私钥来进行加密和解密，加密速度慢，但是密钥传输和管理较为简单，且具有更好的安全性。下面分别介绍常用的对称加密算法和非对称加密算法，并提供相应的 Java 代码示例。
【java基础】Token令牌生成 token加密串 生成token Aes加密 Base64加密 JWT 【附源码】
刘贵庆的博客
09-17 2929
Token令牌-生成工具 包括： 头部（header)+载荷（payload)+签证（signature)
Token：服务端身份验证的流行方案【转】
weixin_34409357的博客
01-24 993
01- 身份认证 服务端提供资源给客户端，但是某些资源是有条件的。所以服务端要能够识别请求者的身份，然后再判断所请求的资源是否可以给请求者。 token是一种身份验证的机制，初始时用户提交账号数据给服务端，服务端采用一定的策略生成一个字符串（token），token字符串中包含了少量的用户信息，并且有一定的期限。服务端会把token字符串传给客户端，客户端保存token字符串，并在接下来的请求...
常用工具类之十四 token认证加密解密工具类(javax.crypto)
taylor的博客
12-04 701
/** * 版权： * 描述： 认证工具类 * 创建时间：2020年11月26日 */ import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import javax.crypto.spec.IvParameterSpec; import lombok.SneakyThrows;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>