package com.ca.my.center.utils;
import io.jsonwebtoken.*;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;
public class AppJwtUtil {
//定义TokenHeader
public static final String AUTH_HEADER_KEY = "Authorization";
// TOKEN的有效期一天(S)
private static final int TOKEN_TIME_OUT = 3600;
// 加密KEY
private static final String TOKEN_ENCRY_KEY = "MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY";
// 最小刷新间隔(S)
private static final int REFRESH_TIME = 300;
private final static String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
private final static String num = "0123456789";
// 生产ID
public static String getToken(Long id) {
Map<String, Object> claimMaps = new HashMap<>();
claimMaps.put("id", id);
long currentTime = System.currentTimeMillis();
return Jwts.builder()
.setId(UUID.randomUUID().toString())
.setIssuedAt(new Date(currentTime)) //签发时间
.setSubject("system") //说明
.setIssuer("changan") //签发者信息
.setAudience("app") //接收用户
.compressWith(CompressionCodecs.GZIP) //数据压缩方式
.signWith(SignatureAlgorithm.HS512, generalKey()) //加密方式
.setExpiration(new Date(currentTime + TOKEN_TIME_OUT * 1000)) //过期时间戳
.addClaims(claimMaps) //cla信息
.compact();
}
/**
* 获取token中的claims信息
*
* @param token
* @return
*/
private static Jws<Claims> getJws(String token) {
return Jwts.parser()
.setSigningKey(generalKey())
.parseClaimsJws(token);
}
/**
* 获取payload body信息
*
* @param token
* @return
*/
public static Claims getClaimsBody(String token) {
try {
return getJws(token).getBody();
} catch (ExpiredJwtException e) {
return null;
}
}
/**
* 获取hearder body信息
*
* @param token
* @return
*/
public static JwsHeader getHeaderBody(String token) {
return getJws(token).getHeader();
}
/**
* 是否过期
*
* @param claims
* @return -1:有效,0:有效,1:过期,2:过期
*/
public static int verifyToken(Claims claims) {
if (claims == null) {
return 1;
}
try {
claims.getExpiration()
.before(new Date());
// 需要自动刷新TOKEN
if ((claims.getExpiration().getTime() - System.currentTimeMillis()) > REFRESH_TIME * 1000) {
return -1;
} else {
return 0;
}
} catch (ExpiredJwtException ex) {
return 1;
} catch (Exception e) {
return 2;
}
}
/**
* 由字符串生成加密key
*
* @return
*/
public static SecretKey generalKey() {
byte[] encodedKey = Base64.getEncoder().encode(TOKEN_ENCRY_KEY.getBytes());
SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
return key;
}
public static void main(String[] args) {
/* Map map = new HashMap();
map.put("id","11");*/
System.out.println(AppJwtUtil.getToken(1102L));
Jws<Claims> jws = AppJwtUtil.getJws("eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAADWLQQqEMAwA_5KzhURNt_qb1KZYQSi0wi6Lf9942NsMw3zh6AVW2DYmDGl2WabkZgreCaM6VXzhFBfJMcMARTqsxIG9Z888QLui3e3Tup5Pb81013KKmVzJTGo11nf9n8v4nMUaEY73DzTabjmDAAAA.4SuqQ42IGqCgBai6qd4RaVpVxTlZIWC826QA9kLvt9d-yVUw82gU47HDaSfOzgAcloZedYNNpUcd18Ne8vvjQA");
Claims claims = jws.getBody();
System.out.println(claims.get("id"));
}
/**
* 生成盐
*
* @return
*/
public static String salt() {
String uuid = new String();
for (int i = 0; i < 8; i++) {
char ch = str.charAt(new Random().nextInt(str.length()));
uuid += ch;
}
return uuid;
}
}
package com.ca.my.center.utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import java.security.Key;
import java.security.MessageDigest;
/**
* 加密解密的工具类
*
* @author bc
*
*/
public final class CryptionUtil {
/**
* 日志
*/
private static Logger logger = LoggerFactory.getLogger(CryptionUtil.class);
// 算法数组
private static final String ALGORITHM_MD5 = "MD5";
// UTF-8字符串
private static final String UTF8 = "utf-8";
/**
* 隐藏工具类的构造方法
*/
private CryptionUtil() {
}
/**
* 加密
*
* @param plaintext
* @param key
* @return
*/
public static String encrypt(String plaintext, Key key) {
try {
// 使用密钥加密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
// 加密后
byte[] result = cipher.doFinal(plaintext.getBytes(UTF8));
// 返回结果
return KeyUtil.encryptBASE64(result);
} catch (Exception e) {
// 打印日志
logger.error("加密异常", e);
return null;
}
}
/**
* 解密
*
* @param ciphertext
* @param key
* @return
*/
public static String decrypt(String ciphertext, Key key) {
try {
// 使用密钥解密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
// 解密后
byte[] result = cipher.doFinal(KeyUtil.decryptBASE64(ciphertext));
// 返回结果
return new String(result, UTF8);
} catch (Exception e) {
// 打印日志
logger.error("解密异常", e);
return null;
}
}
/**
* 公钥加密
*
* @param plaintext
* @param key
* @return
*/
public static String publicKeyEncrypt(String plaintext,
String publicKeyBase64) {
Key key = KeyUtil.publicKeyBase64ToKey(publicKeyBase64);
try {
// 使用密钥加密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
// 加密后
byte[] result = cipher.doFinal(plaintext.getBytes(UTF8));
// 返回结果
return KeyUtil.encryptBASE64(result);
} catch (Exception e) {
// 打印日志
logger.error("公钥加密异常", e);
return null;
}
}
/**
* 公钥解密
*
* @param ciphertext
* @param key
* @return
*/
public static String publicKeyDecrypt(String ciphertext,
String publicKeyBase64) {
Key key = KeyUtil.publicKeyBase64ToKey(publicKeyBase64);
try {
// 使用密钥解密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
// 解密后
byte[] result = cipher.doFinal(KeyUtil.decryptBASE64(ciphertext));
// 返回结果
return new String(result, UTF8);
} catch (Exception e) {
// 打印日志
logger.error("公钥解密异常", e);
return null;
}
}
/**
* 私钥加密
*
* @param plaintext
* @param key
* @return
*/
public static String privateKeyEncrypt(String plaintext,
String privateKeyBase64) {
Key key = KeyUtil.privateKeyBase64ToKey(privateKeyBase64);
try {
// 使用密钥加密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
// 加密后
byte[] result = cipher.doFinal(plaintext.getBytes(UTF8));
// 返回结果
return KeyUtil.encryptBASE64(result);
} catch (Exception e) {
// 打印日志
logger.error("私钥加密异常", e);
return null;
}
}
/**
* 私钥解密
*
* @param ciphertext
* @param key
* @return
*/
public static String privateKeyDecrypt(String ciphertext,
String privateKeyBase64) {
Key key = KeyUtil.privateKeyBase64ToKey(privateKeyBase64);
try {
// 使用密钥解密
Cipher cipher = Cipher.getInstance(KeyUtil.KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
// 解密后
byte[] result = cipher.doFinal(KeyUtil.decryptBASE64(ciphertext));
// 返回结果
return new String(result, UTF8);
} catch (Exception e) {
// 打印日志
logger.error("私钥解密异常", e);
return null;
}
}
/**
* 取摘要
*
* @param plaintext
* @param algorithm
* @return
*/
private static String digest(String plaintext, String algorithm) {
try {
// 生成指定算法的MessageDigest的对象
MessageDigest md = MessageDigest.getInstance(algorithm);
// 重置MessageDigest对象
md.reset();
// 得到摘要
md.update(plaintext.getBytes("utf-8"));
// StringBuffer
StringBuffer buf = new StringBuffer();
// 得到摘要
byte[] encodedPassword = md.digest();
// 字节数组转字符串
for (int i = 0; i < encodedPassword.length; i++) {
if ((encodedPassword[i] & 0xFF) < 16) {
buf.append("0");
}
buf.append(Long.toString(encodedPassword[i] & 0xFF, 16));
}
// 返回密文
return buf.toString();
} catch (Exception e) {
// 打印日志
logger.error("密码加密异常", e);
return null;
}
}
/**
* 对密码加密
*
* @param password
* @return
*/
public static String encryptPassword(String password, String salt, int type) {
// 加密后的密码
String ciphertext = "";
// 根据加密类型选择加密方式
switch (type) {
// md5(password+salt)
case 0:
ciphertext = digest(password.concat(salt), ALGORITHM_MD5);
break;
// md5(md5(password)+salt)
case 1:
String digest = digest(password, ALGORITHM_MD5);
if (null != digest) {
ciphertext = digest(digest.concat(salt),
ALGORITHM_MD5);
}
break;
// 默认
default:
break;
}
// 返回密文
return ciphertext;
}
}
使用:
String salt = AppJwtUtil.salt(); String encryptPassword = CryptionUtil.encryptPassword(wikiSysUser.getPassword(), salt, 0);