接口安全机制
des.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>DES算法</title>
<script src="/js/jquery.min.js"></script>
<script src="/js/tripledes.js"></script>
<script src="/js/mode-ecb-min.js"></script>
<script>
function uuid() {
var s = [];
var hexDigits = "0123456789abcdef";
for (var i = 0; i < 36; i++) {
s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
}
s[14] = "4"; // bits 12-15 of the time_hi_and_version field to 0010
s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01
s[8] = s[13] = s[18] = s[23] = "-";
var uuid = s.join("");
return uuid;
}
/*
* 加密函数
* message - 要加密的源数据
* key - 密钥
*/
function encryptByDES(message, key) {
// 解析密钥， 将密钥转换成16进制数据。 就是解析为字节数据。
var keyHex = CryptoJS.enc.Utf8.parse(key);
// 创建DES加密工具。 构建器。
var encrypted = CryptoJS.DES.encrypt(message, keyHex, {
mode: CryptoJS.mode.ECB, // 加密的模式， ECB加密模式。
padding: CryptoJS.pad.Pkcs7 // 加密的padding
});
return encrypted.toString(); // 加密，并获取加密后的密文数据。
}
/*
* 解密函数
* ciphertext - 要解密的密文数据。
* key - 密钥
*/
function decryptByDES(ciphertext, key) {
var keyHex = CryptoJS.enc.Utf8.parse(key);
// 创建解密工具
var decrypted = CryptoJS.DES.decrypt({
ciphertext: CryptoJS.enc.Base64.parse(ciphertext) // 将密文数据解析为可解密的字节数据。
}, keyHex, {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
});
return decrypted.toString(CryptoJS.enc.Utf8); // 解密过程，并返回明文。
}
function doPost(){
var name = $("#nameText").val();
var password = $("#passwordText").val();
var message = name + password;
var key = uuid();
var param = {};
param.name=name;
param.password=password;
param.key=key;
// 正确的加密
param.message = encryptByDES(message, key);
// 测试解密错误，如：请求拦截。
// param.message = "WrongSecurityMessage00";
// 测试异常情况。DES加密后的密文数据长度一定是8的整数倍。
// param.message = "testException";
$.ajax({
'url':'/testDes',
'data':param,
'success':function(data){
if(data){
alert("密文："+data.securityMessage+"；key："+data.key);
var respMsg = decryptByDES(data.securityMessage, data.key);
alert(respMsg);
}else{
alert("服务器忙请稍后重试!");
}
}
});
}
</script>
</head>
<body>
<center>
<table>
<caption>DES安全测试</caption>
<tr>
<td style="text-align: right; padding-right: 5px">
姓名：
</td>
<td style="text-align: left; padding-left: 5px">
<input type="text" name="name" id="nameText"/>
</td>
</tr>
<tr>
<td style="text-align: right; padding-right: 5px">
密码：
</td>
<td style="text-align: left; padding-left: 5px">
<input type="text" name="password" id="passwordText"/>
</td>
</tr>
<tr>
<td style="text-align: right; padding-right: 5px" colspan="2">
<input type="button" value="测试" onclick="doPost();" />
</td>
</tr>
</table>
</center>
</body>
</html>DesService.java
package com.sxt.service;
import com.sxt.des.utils.DesResponse;
public interface DesService {
public DesResponse testDes(String key, String securityMessage, String name, String password);
}
DesServiceImpl.java
package com.sxt.service.impl;
import org.springframework.stereotype.Service;
import com.sxt.des.utils.DesCrypt;
import com.sxt.des.utils.DesResponse;
import com.sxt.service.DesService;
@Service
public class DesServiceImpl implements DesService {
@Override
public DesResponse testDes(String key, String securityMessage, String name, String password) {
System.out.println("接收到的密文： " + securityMessage);
System.out.println("请求参数name：" + name + " ； 请求参数password：" + password);
System.out.println("请求key： " + key);
DesResponse resp = new DesResponse();
String respKey = DesCrypt.getKEY();
String message = "";
// 解密解析请求数据
try{
// 解密得到请求源参数
String decodeMessage = DesCrypt.decode(key, securityMessage);
System.out.println("解密后的数据：" + decodeMessage);
// 校验请求参数
if(!decodeMessage.equals((name + password))){
// 请求参数校验失败
message = "请求数据被篡改！";
}else{
// 请求参数验证成功
message = "登录成功！";
}
}catch(Exception e){
e.printStackTrace();
// 有解密异常发生。
message = "请求数据解析错误！";
}
System.out.println("响应中的key：" + respKey);
System.out.println("响应消息明文：" + message);
// 加密处理响应数据
try{
message = DesCrypt.encode(respKey, message);
}catch(Exception e){
e.printStackTrace();
// 加密异常发生。
return null;
}
System.out.println("响应消息密文：" + message);
resp.setKey(respKey);
resp.setSecurityMessage(message);
return resp;
}
}
DesCrypt.java
package com.sxt.des.utils;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.IOUtils;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.SecureRandom;
/**
* 加密解密工具类
*/
public class DesCrypt {
// 默认的KEY。此密匙应该根据用户推算或记录在物理存储中。
private static final String KEY = "com.sxt.des";
// 字符编码。
private static final String CODE_TYPE = "UTF-8";
/**
* DES加密
* @param datasource 要加密的源数据。
* @return 加密后的数据。
*/
public static String encode(String key, String datasource) throws Exception{
if(null == key){
key = KEY;
}
// 随机生成器。如果种子一样，则生成的随机信息可推测。
SecureRandom random = new SecureRandom();
// 创建DES密匙。依据提供的密匙字符串创建密匙。 密钥源信息。 需要通过密钥工厂再次推算的，才能得到最终的密钥数据。
DESKeySpec desKey = new DESKeySpec(key.getBytes(CODE_TYPE));
// 创建一个密匙工厂，然后用它把DESKeySpec转换成SecretKey
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey securekey = keyFactory.generateSecret(desKey);
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance("DES");
// 用密匙初始化Cipher对象。 Cipher.ENCRYPT_MODE - 加密模式
cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
// 现在，获取数据并加密。
// 加密后的数据不要new String。 java中的字符串对象都是有字符集信息的。
// java中的UTF8字符集又是长度变化的。一个字符串长度为2~3
byte[] temp = Base64.encodeBase64(cipher.doFinal(datasource.getBytes()));
return IOUtils.toString(temp,"UTF-8");
}
/**
* DES解密
* @param src 要解密的密文数据
* @return
*/
public static String decode(String key, String src) throws Exception {
if(null == key){
key = KEY;
}
// DES算法要求有一个可信任的随机数源
SecureRandom random = new SecureRandom();
// 创建一个DESKeySpec对象
DESKeySpec desKey = new DESKeySpec(key.getBytes(CODE_TYPE));
// 创建一个密匙工厂
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
// 将DESKeySpec对象转换成SecretKey对象
SecretKey securekey = keyFactory.generateSecret(desKey);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance("DES");
// 用密匙初始化Cipher对象。 Cipher.DECRYPT_MODE - 解密模式
cipher.init(Cipher.DECRYPT_MODE, securekey, random);
// 真正开始解密操作
return IOUtils.toString(cipher.doFinal(Base64.decodeBase64(src)),"UTF-8");
}
public static String getKEY(){
return KEY;
}
}
DesController.java
package com.sxt.des.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.sxt.des.utils.DesResponse;
import com.sxt.service.DesService;
@Controller
public class DesController {
@Autowired
private DesService desService;
/**
* 加密逻辑为： name+password 使用key作为密匙源，加密得到securityMessage
* @param key 密匙源
* @param securityMessage 加密后的签名
* @param name 用户名
* @param password 密码
* @return
*/
@RequestMapping("/testDes")
@ResponseBody
public DesResponse testDes(@RequestParam("key") String key, @RequestParam("message") String securityMessage
, @RequestParam("name") String name, @RequestParam("password") String password){
DesResponse resp = this.desService.testDes(key, securityMessage, name, password);
return resp;
}
}
DesResponse.java
package com.sxt.des.utils;
public class DesResponse {
private String key;
private String securityMessage;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getSecurityMessage() {
return securityMessage;
}
public void setSecurityMessage(String securityMessage) {
this.securityMessage = securityMessage;
}
}
aes.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>AES算法</title>
<script src="/js/jquery.min.js"></script>
<script src="/js/aes.min.js"></script>
<script>
// 随机数生成算法。 len-生成结果的长度， radix-生成结果的组成，是二进制，十进制还是十六进制数。
function uuid(len, radix) {
var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
var uuid = [], i;
radix = radix || chars.length;
if (len) {
// Compact form
for (i = 0; i < len; i++) uuid[i] = chars[0 | Math.random()*radix];
} else {
// rfc4122, version 4 form
var r;
// rfc4122 requires these characters
uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
uuid[14] = '4';
// Fill in random data. At i==19 set the high bits of clock sequence as
// per rfc4122, sec. 4.1.5
for (i = 0; i < 36; i++) {
if (!uuid[i]) {
r = 0 | Math.random()*16;
uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
}
}
}
return uuid.join('');
}
/*
* 加密函数
* message - 明文数据
* key - 密钥
*/
function encryptByAES(message, key){
var keyHex = CryptoJS.enc.Utf8.parse(key);
var srcs = CryptoJS.enc.Utf8.parse(message);
var encrypted = CryptoJS.AES.encrypt(srcs, keyHex, {
mode:CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
});
return encrypted.toString();
}
/*
* 解密函数
* ciphertext - 要解密的密文。
*/
function decryptByAES(ciphertext, key){
var keyHex = CryptoJS.enc.Utf8.parse(key);
var decrypt = CryptoJS.AES.decrypt(ciphertext, keyHex, {
mode:CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
});
return CryptoJS.enc.Utf8.stringify(decrypt).toString();
}
function doPost(){
var name = $("#nameText").val();
var password = $("#passwordText").val();
var message = name + password;
var key = uuid(32,16);
var param = {};
param.name=name;
param.password=password;
param.key=key;
// 正确的加密
param.message = encryptByAES(message, key);
// 测试解密错误，如：请求拦截。
// param.message = "WrongSecurityMessage00";
// 测试异常情况。AES加密后的密文数据长度一定是8的整数倍。
// param.message = "testException";
$.ajax({
'url':'/testAes',
'data':param,
'success':function(data){
if(data){
alert("密文："+data.securityMessage+"；key："+data.key);
var respMsg = decryptByAES(data.securityMessage, data.key);
alert(respMsg);
}else{
alert("服务器忙请稍后重试!");
}
}
});
}
</script>
</head>
<body>
<center>
<table>
<caption>AES安全测试</caption>
<tr>
<td style="text-align: right; padding-right: 5px">
姓名：
</td>
<td style="text-align: left; padding-left: 5px">
<input type="text" name="name" id="nameText"/>
</td>
</tr>
<tr>
<td style="text-align: right; padding-right: 5px">
密码：
</td>
<td style="text-align: left; padding-left: 5px">
<input type="text" name="password" id="passwordText"/>
</td>
</tr>
<tr>
<td style="text-align: right; padding-right: 5px" colspan="2">
<input type="button" value="测试" onclick="doPost();" />
</td>
</tr>
</table>
</center>
</body>
</html>AesController.java
package com.sxt.aes.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.sxt.aes.service.AesService;
import com.sxt.aes.utils.AesResponse;
@Controller
public class AesController {
@Autowired
private AesService aesService;
/**
* 加密逻辑为： name+password 使用key作为密匙源，加密得到securityMessage
* @param key 密匙源
* @param securityMessage 加密后的签名
* @param name 用户名
* @param password 密码
* @return
*/
@RequestMapping("/testAes")
@ResponseBody
public AesResponse testDes(@RequestParam("key") String key, @RequestParam("message") String securityMessage
, @RequestParam("name") String name, @RequestParam("password") String password){
AesResponse resp = this.aesService.testAes(key, securityMessage, name, password);
return resp;
}
}
AesService.java
package com.sxt.aes.service;
import com.sxt.aes.utils.AesResponse;
public interface AesService {
public AesResponse testAes(String key, String securityMessage, String name, String password);
}
AesServiceImpl.java
package com.sxt.aes.service.impl;
import org.springframework.stereotype.Service;
import com.sxt.aes.service.AesService;
import com.sxt.aes.utils.AesCrypt;
import com.sxt.aes.utils.AesResponse;
@Service
public class AesServiceImpl implements AesService {
@Override
public AesResponse testAes(String key, String securityMessage, String name, String password) {
System.out.println("接收到的密文： " + securityMessage);
System.out.println("请求参数name：" + name + " ； 请求参数password：" + password);
System.out.println("请求key： " + key);
AesResponse resp = new AesResponse();
String respKey = AesCrypt.getKEY();
String message = "";
// 解密解析请求数据
try{
// 解密得到请求源参数
String decodeMessage = AesCrypt.aesDecrypt(securityMessage, key);
System.out.println("解密后的数据：" + decodeMessage);
// 校验请求参数
if(!decodeMessage.equals((name + password))){
// 请求参数校验失败
message = "请求数据被篡改！";
}else{
// 请求参数验证成功
message = "登录成功！";
}
}catch(Exception e){
e.printStackTrace();
// 有解密异常发生。
message = "请求数据解析错误！";
}
System.out.println("响应中的key：" + respKey);
System.out.println("响应消息明文：" + message);
// 加密处理响应数据
try{
message = AesCrypt.aesEncrypt(message, respKey);
}catch(Exception e){
e.printStackTrace();
// 加密异常发生。
return null;
}
System.out.println("响应消息密文：" + message);
resp.setKey(respKey);
resp.setSecurityMessage(message);
return resp;
}
}
AesResponse.java
package com.sxt.aes.utils;
public class AesResponse {
private String key;
private String securityMessage;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getSecurityMessage() {
return securityMessage;
}
public void setSecurityMessage(String securityMessage) {
this.securityMessage = securityMessage;
}
}
AesCrypt.java
package com.sxt.aes.utils;
import java.math.BigInteger;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import sun.misc.BASE64Decoder;
/**
* AES的加密和解密
* @author libo
*/
public class AesCrypt {
// 密钥 ，长度是16
private static final String KEY = "com.sxt.aes.keys";
// 算法
private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
// private static final String ALGORITHMSTR = "AES/CBC/PKCS5Padding";
/**
* 将byte[]转为各种进制的字符串
* @param bytes byte[]
* @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
* @return 转换后的字符串
*/
public static String binary(byte[] bytes, int radix){
return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
}
/**
* base 64 encode
* @param bytes 待编码的byte[]
* @return 编码后的base 64 code
*/
public static String base64Encode(byte[] bytes){
return Base64.encodeBase64String(bytes);
}
/**
* base 64 decode
* @param base64Code 待解码的base 64 code
* @return 解码后的byte[]
* @throws Exception
*/
public static byte[] base64Decode(String base64Code) throws Exception{
return StringUtils.isEmpty(base64Code) ? null : new BASE64Decoder().decodeBuffer(base64Code);
}
/**
* AES加密
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的byte[]
* @throws Exception
*/
public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
// 密钥生成器
// KeyGenerator kgen = KeyGenerator.getInstance("AES");
// 密钥生成器初始化， 密钥生成器初始化，会影响到Cipher的处理。
// kgen.init(128);
Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
/*// AES/CBC/PKCS5Padding 算法模式为CBC可以增加偏移量，可增加加密算法强度。
String ivParameter = "0392039203920300";
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"), iv);
*/
// 初始化， Cipher.ENCRYPT_MODE-加密模式， SecretKeySpec-具体的密钥
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"));
return cipher.doFinal(content.getBytes("utf-8"));
}
/**
* AES加密为base 64 code
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的base 64 code
* @throws Exception
*/
public static String aesEncrypt(String content, String encryptKey) throws Exception {
return base64Encode(aesEncryptToBytes(content, encryptKey));
}
/**
* AES解密
* @param encryptBytes 待解密的byte[]
* @param decryptKey 解密密钥
* @return 解密后的String
* @throws Exception
*/
public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
/* KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128); */
Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
// Cipher.DECRYPT_MODE - 解密模式
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
/**
* 将base 64 code AES解密
* @param encryptStr 待解密的base 64 code
* @param decryptKey 解密密钥
* @return 解密后的string
* @throws Exception
*/
public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
return StringUtils.isEmpty(encryptStr) ? null : aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
}
public static String getKEY(){
return KEY;
}
/**
* 测试
*/
public static void main(String[] args) throws Exception {
String content = "testtest";
System.out.println("加密前：" + content);
System.out.println("加密密钥和解密密钥：" + KEY);
String encrypt = aesEncrypt(content, KEY);
System.out.println("加密后：" + encrypt);
String decrypt = aesDecrypt(encrypt, KEY);
System.out.println("解密后：" + decrypt);
}
}
1025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
