单点登录SSO----接口安全机制(双向加密{DES/AES})

最新推荐文章于 2022-11-07 11:03:21 发布

Miracle_Gaaral

最新推荐文章于 2022-11-07 11:03:21 发布

阅读量874

点赞数

分类专栏：单点登录SSO

本文链接：https://blog.csdn.net/Miracle_Gaaral/article/details/101720098

版权

单点登录SSO 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

接口安全机制

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);  
    } 
}

Miracle_Gaaral

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
单点登录SSO----接口安全机制(双向加密{DES/AES})

接口安全机制des.jsp<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><html><head> <meta http-equiv="content-type" content="text/...
复制链接

扫一扫