文章目录

一、网络安全

1、网络安全概述
2、加密，系统安全措施

一、网络安全

1、网络安全概述

（1）通常的网络安全有SQL注入，XSS脚本攻击，CRSF伪脚本攻击，DDOS拒绝服务攻击。

（2）SQL注入
所谓SQL注入，就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。
预防方式：

使用预编译
使用ORM框架
执行sql语句是使用addslashes进行sql语句转换
sql语句书写尽量不要省略双引号和单引号
过滤掉sql语句里的关键词：update insert delete select *
PHP配置文件中设置register_global为off，关闭全局变量注册
控制错误信息不要把错误信息输出到浏览器上应保存在错误日

（3）XSS攻击
XSS攻击的全称是跨站脚本攻击，指的是攻击者在网页中嵌入恶意脚本程序，如<script>alert(1111)</script>。当用户打开该网页时，脚本程序便开始在客户端的浏览器上执行，以盗取客户端cookie，用户名密码，下载执行病毒密码程序，甚至是获取客户端admin权限等。
预防方式：

在前端进行输入验证，如果发现类似脚本程序的输入，就将其转义。
在后端接收到数据的时候进行验证和转义。

（4） CRSF攻击
CRSF攻击的全称是跨站请求伪造，是一种对网站的恶意利用，XSS利用的是站点内的信任用户，而CRSF则是通过伪装来自受信任用户的请求来利用受信任的网站。
预防方式：

Cookie Hashing(所有表单都包含同一个伪随机值)：
验证码
One-Time Tokens(不同的表单包含一个不同的伪随机值)

（5）DDOS拒绝服务攻击
DDOS流量攻击
预防方式：

使用工具:DDOS deflate . 自动查封IP.e
析域名到127.0.0.1 让攻击方自己攻击自己
把网站做成静态页面
制S YN/ICMP流量
通过提高服务端的配置，比如：宽带，并发量
在服务端限制第二次握手的时间，如果时间超时，就直接把这个连接断开，并从链接列表中清除相关信息。

2、加密，系统安全措施

（1）加密三种方式：不可逆加密、对称加密、不对称加密
（2）不可逆加密
不可逆加密的加密结果没法解密，典型的有：MD5、sha256、HMAC加密

① MD5加密

不可逆运算，对不同的数据加密的结果是定长的32位字符（不管文件多大都一样），对相同的数据加密，得到的结果是一样的（也就是复制）。
抗修改性 : 信息“指纹”，对原数据进行任何改动,哪怕只修改一个字节,所得到的 MD5 值都有很大区别.
弱抗碰撞 : 已知原数据和其 MD5 值,想找到一个具有相同 MD5 值的数据(即伪造数据)是非常困难的.
强抗碰撞: 想找到两个不同数据,使他们具有相同的 MD5 值,是非常困难的

public class EncUtils {
	public static String MD5Enc(String password) {
		return DigestUtils.md5Hex(password);
	}
}

如果想要加密更深，可以用循环再加密。

public class EncUtils {
	public static String MD5Enc(String password) {
		for(int i = 0; i < 1024; i++) {
			password = DigestUtils.md5Hex(password);
		}
		return password;
	}
}

② sha256加密

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。
对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。当让除了SHA1还有SHA256以及SHA512等。
SHA1特性：
- 不可以从消息摘要中复原信息；
- 两个不同的消息不会产生同样的消息摘要。

public class EncUtils {
	public static String sha256Enc(String password) {
		for(int i = 0; i < 1024; i++) {
			password = DigestUtils.sha256Hex(password);
		}
		return password;
	}
}

③ HMAC加密

HMAC：给定一个密钥，对明文加密，做两次“散列”，得到的结果还是32为字符串。在实际开发中，密钥是服务器生成，客户端发送请求会拿到KEY，一个账号对应一个KEY。
以注册为例：当用户把账号提交给服务器，服务器会验证账号的合法性，如果合法就会生成个KEY给客户端（这个KEY只有在注册的时候会出现一次，一个账号只对应一个KEY）；客户端会用拿到的KEY给密码用HMAC方式加密（32位字符串）发给服务器，最终服务器会保存这个HMAC密码。这样就注册成功了！以后再登录就会服务器就会比对这个HMAC密码是否相等决定能否登录成功。

（3）对称加密
对称加密算法又称传统加密算法，对称加密跟解密使用的是相同的密钥，加密解密过程：明文->密钥加密->密文，密文->密钥解密->明文。典型的有：DES（80年代）、3DES、AES（目前常用）（相对不安全）

① DES(Data Encryption Standard)
数据加密标准(现在用的比较少，因为它的加密强度不够，能够暴力破解) 。

② 3DES
原理和DES几乎是一样的，只是使用3个密钥，对相同的数据执行三次加密，增强加密强度。(缺点：要维护3个密钥，大大增加了维护成本) 。

③ AES(Advanced Encryption Standard)

AES是高级加密标准，目前美国国家安全局使用的，苹果的钥匙串访问采用的就AES加密。是现在公认的最安全的加密方式，是对称密钥加密中最流行的算法。
AES的安全性相对RSA较低，但是效率比RAS高，AES应用于https协议的ssl协议的底层实现。

AES加密Demo
AES解密工具 AESUtils 类

public class AESUtils {
    //密钥 (需要前端和后端保持一致)
    private static final String KEY = "abcdefgabcdefg12";
    //算法,ECB定义AES的计算模式，加密算法标准
    private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
    
    //aes解密
    public static String decr(String content) {
        byte[] mes = null;
        try {
            @SuppressWarnings("restriction")
			byte[] base64Content = new BASE64Decoder().decodeBuffer(content);
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(KEY.getBytes(),"AES"));
            mes = new byte[0];
            mes = cipher.doFinal(base64Content);
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new String(mes);
    }
   }

控制层 UsersController 类

@RestController
public class UsersController {
	@Resource
	private UsersService us;
	
	@GetMapping("login")
	public String select(String userName, String userPassword) throws Exception {
		System.out.println("AES解密前：" + userPassword);
		userPassword = AESUtils.decr(userPassword);
		System.out.println("AES解密后：" + userPassword);
		System.out.println("userName=" + userName);
		//sha256加密
//		userPassword = EncUtils.sha256Enc(userPassword);
		//MD5加密
		userPassword = EncUtils.MD5Enc(userPassword);
		
		String str = null;
		Users users = us.selectByUserName(userName);
		if(users != null) {
			if(users.getUserPassword().equals(userPassword)) {
				str = "success";
			}else {
				str = "error";
			}
		}else {
			str = "账号不存在";
		}
		return str;
	}
}

前端发送请求网页

<body>
		<form id="login">
	        <input name="userName" id="userName"><br>
	        <input type="password" name="userPassword" id="userPassword"><br>
	        <input type="button" value="登录" onclick="login()">
	    </form>
	    <script type="text/javascript">
	        function login(){
	        	var userName = $("#userName").val();
	        	var userPassword = $("#userPassword").val();
	        	console.log("AES加密前：" + userPassword);
	        	/* 执行加密方法 */
	        	userPassword = encrypt(userPassword);
	        	console.log("AES加密后：" + userPassword);
	            $.ajax({
	                   url:"/login",
	                   type:"get",
	                   data:{"userName":userName, "userPassword":userPassword},
	                   success:function(data){
		                   console.log(data);
		                   if(data == "success"){
		                        location.href="success.html";
		                   }else if(data == "error"){
		                        location.href="error.html";
		                   }
	                   }
	               });
	         }
	        
	        /*加密方法（需要先加载aes.js文件）*/
	        function encrypt(word){
	            var key = CryptoJS.enc.Utf8.parse("abcdefgabcdefg12");
	            var srcs = CryptoJS.enc.Utf8.parse(word);
	            var encrypted = CryptoJS.AES.encrypt(srcs, key, {mode:CryptoJS.mode.ECB,padding: CryptoJS.pad.Pkcs7});
	            return encrypted.toString();
	        }
	
	        /* 解密方法*/
	        function decrypt(word){
	            var key = CryptoJS.enc.Utf8.parse("abcdefgabcdefg12");
	            var decrypt = CryptoJS.AES.decrypt(word, key, {mode:CryptoJS.mode.ECB,padding: CryptoJS.pad.Pkcs7});
	            return CryptoJS.enc.Utf8.stringify(decrypt).toString();
	        }
	    </script>
	</body>

一份比较完整的AES加密工具类

/**
 *AES加密解密工具类
 */
public class AESUtils {
    //密钥 (需要前端和后端保持一致)
    private static final String KEY = "abcdefgabcdefg12";
    //算法,ECB定义AES的计算模式，加密算法标准
    private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
    
    //aes解密
    public static String decr(String content) {
        byte[] mes = null;
        try {
            @SuppressWarnings("restriction")
			byte[] base64Content = new BASE64Decoder().decodeBuffer(content);
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(KEY.getBytes(),"AES"));
            mes = new byte[0];
            mes = cipher.doFinal(base64Content);
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new String(mes);
    }

    /**
     * aes解密
     * @param encrypt   内容
     * @return
     * @throws Exception
     */
    public static String aesDecrypt(String encrypt) {
        try {
            return aesDecrypt(encrypt, KEY);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * aes加密
     * @param content
     * @return
     * @throws Exception
     */
    public static String aesEncrypt(String content) {
        try {
            return aesEncrypt(content, KEY);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 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
     */
    @SuppressWarnings("restriction")
	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");
        kgen.init(128);
        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
        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.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);
    }
}

（4）不对称加密

非对称加密算法又称现代加密算法，非对称加密是计算机通信安全的基石，保证了加密数据不会被破解，典型的有RSA（相对安全）。
非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey) ，公开密钥和私有密钥是一对
- 如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。
- 如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
特点：
算法强度复杂，安全性依赖于算法与密钥。
加密解密速度慢。
与对称加密算法的对比：
- 对称加密只有一种密钥，并且是非公开的，如果要解密就得让对方知道密钥。
- 非对称加密有两种密钥，其中一个是公开的。

① RSA加密

由于RSA算法的加密解密速度要比对称算法速度慢很多，在实际应用中，通常采取数据本身的加密和解密使用对称加密算法(AES)，用RSA算法加密并传输对称算法所需的密钥。

RSA加密Demo：RSA+时间戳完成登录验证

控制层 UsersController 类

@RestController
public class UsersController {
	//记录日志
	private static final Logger log = LoggerFactory.getLogger(UsersController.class);

	//私钥
	private static final String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJX/0JqAPr0mdq9ZN0XqYEVWYApf\r\n" + 
			"EvoNkmzN0tgQ2CrI0Z8rcmw0CiPH1m1Rp0I/DqiA7XTbqQQMpLLjpUGs11MdLnWvhYqJ04CTK7Bm\r\n" + 
			"0OwqtIUYxnwPcfGjoOYI2tFB6xWqp6QkmqcF8NAKf8P5kL6L5mXLpI/+6hqlqiFNzM13AgMBAAEC\r\n" + 
			"gYBgx0ikJpJUH/j7caiD55BtrCkTB/yKcS9EHBgpZ9TQ5fi5paKRxZG1PD5REhnEWELw3R5YA1Gt\r\n" + 
			"Vyr8cHwzP309GaQVrdrmp5/NnnbuR9Eq7uw9CM+Qovs1Elg77DMh68PNoCbunDsrcOM03+Qm56EL\r\n" + 
			"ZqilosDyuf+T/uTMkK/OAQJBAM6Cg1c9xrKzcc/vf8c0dnfslSWGJSrA+0vwVJ2Tpb3zO/K4q9OT\r\n" + 
			"MTlde5QAvDAyBzcebHYcTgtN5wqq5bcLU8ECQQC58lmkx2kn5h9i2OtMFuKgdB8xDMvlOZhrOZ+n\r\n" + 
			"+Na2qyVr9fO4Zs4koy54t82FdxvVl5YSSifgRVi9Wzy31Y83AkBbndVNGBAV6bxdZsCGjQTd8Wy9\r\n" + 
			"yASnMhSKvSWc/wrx+X4oEbvRUqTs8UdJAwZ6T0eaMXom8CnDpB0TQ3xEN9dBAkBdGAtvZvKrqheu\r\n" + 
			"mmF7L734jQqMuRZfxe0cSbY4F2oP/DF5EqMZgEbWquf6QjNgDZje38yfjYbXToC2FLaaZw4TAkAG\r\n" + 
			"6rBZ4zdmOfkjRRJEpHKZ6ZKlqXW9oe+vqQPUBmBD6wKeBxE2ztdHhhjL4Jit87dxjXOLtP3DsZ0s\r\n" + 
			"vdKA/Eme";
	
	@Resource
	private UsersService us;
	
	@GetMapping("login")
	public String select(String userName, String userPassword) throws Exception {
		System.out.println("私钥解密前：" + userPassword);
		//获取私钥
		PrivateKey priKey = RSAUtils.getPrivateKey(privateKey);
		userPassword = userPassword.replaceAll(" ", "+");
		//解密
		userPassword = RSAUtils.decrypt(userPassword, priKey);
		System.out.println("私钥解密后：" + userPassword);
		
		//拆分密钥和时间戳
		String time = userPassword.substring(userPassword.lastIndexOf("+") + 1);
		userPassword = userPassword.substring(0, userPassword.lastIndexOf("+"));
		System.out.println("userPassword =" +userPassword);
		System.out.println("time =" +time);
		long timeBefore = Long.parseLong(time);
		//获取当前时间戳
		long timeNow = System.currentTimeMillis();
		System.out.println(timeBefore +" " + timeNow);
		
		Users users = us.selectByUserName(userName);
		
		String str = null;
		if(users != null) {
			//MD5加密
			userPassword = EncUtils.MD5Enc(userPassword);
			if(users.getUserPassword().equals(userPassword)) {
				if((timeNow - timeBefore) < 1000) {
					str = "success";
				}else {
					str = "登录超时";
				}
			}else {
				str = "error";
			}
		}else {
			str = "账号不存在";
		}
		return str;
	}
}

前端发送请求代码

<body>
	<form id="login">
        <input name="userName" id="userName"><br>
        <input  name="userPassword" id="userPassword"><br>
        <input type="button" value="登录" onclick="login()">
    </form>
    <script type="text/javascript">
        function login(){
        	var userName = $("#userName").val();
        	var userPassword = $("#userPassword").val();
        	console.log("公钥加密前：" + userPassword);
        	
        	/* 定义公钥 */
        	var publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCV/9CagD69JnavWTdF6mBFVmAKXxL6DZJszdLY" +
        		"ENgqyNGfK3JsNAojx9ZtUadCPw6ogO1026kEDKSy46VBrNdTHS51r4WKidOAkyuwZtDsKrSFGMZ8" +
        		"D3Hxo6DmCNrRQesVqqekJJqnBfDQCn/D+ZC+i+Zly6SP/uoapaohTczNdwIDAQAB";
        	//密码添加时间戳
            var time = Date.parse(new Date());
            time = time + 1000;
            userPassword = userPassword + "+" + time;
            console.log("userPassword：" + userPassword);
            /* 执行公钥加密 */
       	    var enctype = new JSEncrypt();//创建RSA对象
            enctype.setPublicKey(publicKey);//为RSA对象设置公钥
            userPassword = enctype.encrypt(userPassword);
        	console.log("公钥加密后：" + userPassword);
        	
            $.ajax({
                   url:"/login",
                   type:"get",
                   data:{"userName":userName, "userPassword":userPassword},
                   success:function(data){
                	   alert(data);
	                   if(data == "success"){
	                        location.href="success.html";
	                   }else if(data == "error"){
	                        location.href="error.html";
	                   }
                   }
              });
            }
		}
   </script>
</body>

获取公钥私钥字符串

KeyPair keyPair = RSAUtils.getKeyPair();
String publicKey = RSAUtils.getPublicKeyStr(keyPair);
String privateKey = RSAUtils.getPrivateKeyStr(keyPair);
System.out.println(publicKey);
System.out.println(privateKey);
SpringApplication.run(App.class, args);

RSA加密工具类

public class RSAUtils {
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;
    
    //获取公钥字符串
    public static String getPublicKeyStr(KeyPair keyPair){
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        byte[] by = publicKey.getEncoded();
        return Base64.encode(by);
    }
    
   //获取私钥字符串
    public static String getPrivateKeyStr(KeyPair keyPair){
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        byte[] by = privateKey.getEncoded();
        return Base64.encode(by);
    }

    /**
     * 获取密钥对
     *
     * @return 密钥对
     */
    public static KeyPair getKeyPair() {
        KeyPairGenerator generator = null;
        try {
            generator = KeyPairGenerator.getInstance("RSA");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        generator.initialize(1024);
        return generator.generateKeyPair();
    }

    /**
     * 获取私钥
     *
     * @param privateKey 私钥字符串
     * @return
     */
    public static PrivateKey getPrivateKey(String privateKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] decodedKey = Base64.decode(privateKey.getBytes());
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 获取公钥
     *
     * @param publicKey 公钥字符串
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] decodedKey = Base64.decode(publicKey.getBytes());
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * RSA加密
     *
     * @param data 待加密数据
     * @param publicKey 公钥
     * @return
     */
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int inputLen = data.getBytes().length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offset = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offset > 0) {
            if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
            }
            out.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
        // 加密后的字符串
        return new String(Base64.decode(encryptedData));
    }

    /**
     * RSA解密
     *
     * @param data 待解密数据
     * @param privateKey 私钥
     * @return
     */
    public static String decrypt(String data, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] dataBytes = Base64.decode(data);
        int inputLen = dataBytes.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offset = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offset > 0) {
            if (inputLen - offset > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
            }
            out.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        // 解密后的内容
        return new String(decryptedData, "UTF-8");
    }

    /**
     * 签名
     *
     * @param data 待签名数据
     * @param privateKey 私钥
     * @return 签名
     */
    public static String sign(String data, PrivateKey privateKey) throws Exception {
        byte[] keyBytes = privateKey.getEncoded();
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey key = keyFactory.generatePrivate(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(key);
        signature.update(data.getBytes());
        return new String(Base64.decode(signature.sign()));
    }

    /**
     * 验签
     *
     * @param srcData 原始字符串
     * @param publicKey 公钥
     * @param sign 签名
     * @return 是否验签通过
     */
    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
        byte[] keyBytes = publicKey.getEncoded();
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey key = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(key);
        signature.update(srcData.getBytes());
        return signature.verify(Base64.decode(sign.getBytes()));
    }
}

三块五的海景房

发布了40 篇原创文章 · 获赞 0 · 访问量 339

私信关注

网络安全 —— 网络加密（不可逆加密、对称加密、不对称加密）

文章目录

一、网络安全

1、网络安全概述

2、加密，系统安全措施

猜你喜欢