java 客户端和服务端加密,RSA 加密解密，客户端JS加密，服务端JAVA解密

最新推荐文章于 2024-09-27 14:30:47 发布
最新推荐文章于 2024-09-27 14:30:47 发布
阅读量331 收藏 1
点赞数
文章标签： java 客户端和服务端加密

JS加密依赖：jsencrypt.js

Github地址：https://github.com/travist/jsencrypt

可客户端尽量依赖JAVA自带的Jar，只是Base64加密的时候额外依赖了apache的工具类commons-net-3.3.jar

服务端工RSA工具类

package com.wzh.config.utils;

import org.apache.commons.net.util.Base64;

import org.apache.log4j.Logger;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.HashMap;

import java.util.Map;

/**

*

*

* @author wzh

* @version 2018-12-16 18:20

* @see [相关类/方法] (可选)

**/

public class RsaUtils

{

private static Logger log = Logger.getLogger(RsaUtils.class);

/**

* 块加密大小

*/

private static final int CACHE_SIZE = 1024;

/**

* 加密算法RSA

*/

public static final String KEY_ALGORITHM = "RSA";

/**

* 签名算法

*/

public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

/**

* 获取公钥的key

*/

private static final String PUBLIC_KEY = "RsaPublicKey";

/**

* 获取私钥的key

*/

private static final String PRIVATE_KEY = "RsaPrivateKey";

/**

* RSA最大加密明文大小

*/

private static final int MAX_ENCRYPT_BLOCK = 117;

/**

* RSA最大解密密文大小

*/

private static final int MAX_DECRYPT_BLOCK = 128;

/**

* Base64字符串解码为二进制数据

* @param base64

* @return 二进制数据

* @throws Exception

*/

public static byte[] decodeBase64(String base64)

throws Exception

{

return Base64.decodeBase64(base64.getBytes());

}

/**

* 二进制数据编码为Base64字符串

* @param bytes

* @return Base64字符串

* @throws Exception

*/

public static String encodeBase64(byte[] bytes)

throws Exception

{

return new String(Base64.encodeBase64(bytes));

}

/**

* 生成秘钥对

* @return 返回公钥和私钥的Map集合

* @throws Exception

*/

public static Map initKeyPair()

throws Exception

{

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);

keyPairGen.initialize(CACHE_SIZE);

KeyPair keyPair = keyPairGen.generateKeyPair();

RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();

RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();

Map keyMap = new HashMap(2);

// 公钥

keyMap.put(PUBLIC_KEY, publicKey);

// 私钥

keyMap.put(PRIVATE_KEY, privateKey);

return keyMap;

}

/**

* 获取私钥

* @param keyMap 秘钥对Map

* @return 私钥字符串

* @throws Exception

*/

public static String getPrivateKey(Map keyMap) throws Exception {

Key key = (Key) keyMap.get(PRIVATE_KEY);

return encodeBase64(key.getEncoded());

}

/**

* 获取公钥字符串

* @param keyMap 秘钥对Map

* @return 公钥字符串

* @throws Exception

*/

public static String getPublicKey(Map keyMap) throws Exception {

Key key = (Key) keyMap.get(PUBLIC_KEY);

return encodeBase64(key.getEncoded());

}

/**

* 使用私钥生成数字签名

* @param data 使用私钥加密的数据

* @param privateKey 是哟啊字符串

* @return 数字签名

* @throws Exception

*/

public static String sign(byte[] data, String privateKey) throws Exception {

// 获取byte数组

byte[] keyBytes = decodeBase64(privateKey);

// 构造PKCS8EncodedKeySpec对象

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

// 指定的加密算法

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

// 取私钥匙对象

PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

// 用私钥对信息生成数字签名

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initSign(privateK);

signature.update(data);

return encodeBase64(signature.sign());

}

/**

* 校验数字签名

* @param data 私钥加密的数据

* @param publicKey 公钥字符串

* @param sign 私钥生成的签名

* @return 校验成功返回true 失败返回false

* @throws Exception

*/

public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {

// 获取byte数组

byte[] keyBytes = decodeBase64(publicKey);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

// 构造X509EncodedKeySpec对象

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

// 指定的加密算法

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

// 取公钥匙对象

PublicKey publicK = keyFactory.generatePublic(keySpec);

signature.initVerify(publicK);

signature.update(data);

// 验证签名是否正常

return signature.verify(decodeBase64(sign));

}

/**

* 私钥加密

* @param data 需要加密的数据

* @param privateKey 私钥

* @return 加密后的数据

* @throws Exception

*/

public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {

byte[] keyBytes = decodeBase64(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, privateK);

int inputLen = data.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, offSet, MAX_ENCRYPT_BLOCK);

} else {

cache = cipher.doFinal(data, offSet, inputLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_ENCRYPT_BLOCK;

}

byte[] encryptedData = out.toByteArray();

out.close();

return encryptedData;

}

/**

* 公钥加密

* @param data 需要加密的数据

* @param publicKey 公钥字符串

* @return 加密后的数据

* @throws Exception

*/

public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {

byte[] keyBytes = decodeBase64(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

Key publicK = keyFactory.generatePublic(x509KeySpec);

// 对数据加密

Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, publicK);

int inputLen = data.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, offSet, MAX_ENCRYPT_BLOCK);

} else {

cache = cipher.doFinal(data, offSet, inputLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_ENCRYPT_BLOCK;

}

byte[] encryptedData = out.toByteArray();

out.close();

return encryptedData;

}

/**

* 私钥解密

* @param encryptedData 公钥加密的数据

* @param privateKey 私钥字符串

* @return 私钥解密的数据

* @throws Exception

*/

public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {

byte[] keyBytes = decodeBase64(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, privateK);

int inputLen = encryptedData.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(encryptedData, offSet, MAX_DECRYPT_BLOCK);

} else {

cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_DECRYPT_BLOCK;

}

byte[] decryptedData = out.toByteArray();

out.close();

return decryptedData;

}

/**

* 公钥解密

* @param encryptedData 私钥加密的数据

* @param publicKey 公钥字符串

* @return 公钥解密的数据

* @throws Exception

*/

public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {

byte[] keyBytes = decodeBase64(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

Key publicK = keyFactory.generatePublic(x509KeySpec);

Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, publicK);

int inputLen = encryptedData.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(encryptedData, offSet, MAX_DECRYPT_BLOCK);

} else {

cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_DECRYPT_BLOCK;

}

byte[] decryptedData = out.toByteArray();

out.close();

return decryptedData;

}

/**

* 公钥加密方法

* @param data 需加密的字符串

* @param PUBLICKEY 公钥字符串

* @return 加密后的字符串

*/

public static String encryptedDataByPublic(String data, String PUBLICKEY) {

try {

data = encodeBase64(encryptByPublicKey(data.getBytes(), PUBLICKEY));

} catch (Exception e) {

e.printStackTrace();

log.error(e.getMessage(),e);

}

return data;

}

/**

* 私钥解密方法

* @param data 公钥加密的字符串

* @param PRIVATEKEY 私钥字符串

* @return 私钥解密的字符串

*/

public static String decryptDataByPrivate(String data, String PRIVATEKEY) {

String temp = "";

try {

byte[] rs = decodeBase64(data);

//以utf-8的方式生成字符串

temp = new String(decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8");

} catch (Exception e) {

e.printStackTrace();

}

return temp;

}

public static void main(String[] args) {

try {

Map keyMap = RsaUtils.initKeyPair();

String publicKey = RsaUtils.getPublicKey(keyMap);

String privateKey = RsaUtils.getPrivateKey(keyMap);

System.out.println("公钥：" + publicKey);

System.out.println("私钥：" + privateKey);

String source = "我是需要私钥加密的字符串！";

System.out.println("签名验证逻辑，私钥加密--公钥解密，需要加密的字符串：" + source);

byte[] data = source.getBytes();

byte[] encodedData = RsaUtils.encryptByPrivateKey(data, privateKey);

System.out.println("私钥加密后：" + new String(encodedData));

String sign = RsaUtils.sign(encodedData, privateKey);

System.out.println("签名:" + sign);

boolean status = RsaUtils.verify(encodedData, publicKey, sign);

System.out.println("验证结果:" + status);

byte[] decodedData = RsaUtils.decryptByPublicKey(encodedData, publicKey);

String target = new String(decodedData);

System.out.println("公钥解密私钥加密的数据:" + target);

System.out.println("---------公钥加密----私钥解密----------");

// 这里尽量长一点，复制了一段歌词

String msg = "月溅星河，长路漫漫，风烟残尽，独影阑珊；谁叫我身手不凡，谁让我爱恨两难，到后来，" +

"肝肠寸断。幻世当空，恩怨休怀，舍悟离迷，六尘不改；且怒且悲且狂哉，是人是鬼是妖怪，不过是，" +

"心有魔债。叫一声佛祖，回头无岸，跪一人为师，生死无关；善恶浮世真假界,尘缘散聚不分明，难断！" +

"我要这铁棒有何用，我有这变化又如何；还是不安，还是氐惆，金箍当头，欲说还休。我要这铁棒醉舞魔，" +

"我有这变化乱迷浊；踏碎灵霄，放肆桀骜，世恶道险，终究难逃。";

String ecodeMsg = RsaUtils.encryptedDataByPublic(msg,publicKey);

System.out.println("加密后的歌词：" + ecodeMsg);

String decodeMsg = RsaUtils.decryptDataByPrivate(ecodeMsg,privateKey);

System.out.println("解密后的歌词：" + decodeMsg);

} catch (Exception e) {

e.printStackTrace();

}

}

}

首先测试一下工具类，main函数跑一下，成功验证签名，加密，解密

621d8f7e2b44

image.png

客户端JS代码，需要JSEncrypt库，前文有给出github地址，这里对这个库做一个简单的扩展，因为RSA长文本超过秘钥长度要报错，所以需要扩展修改下

/**

* ---------------------------

* 此JS需加载JSEncrypt库的后面，加密解密调用着两个方法

* ---------------------------

*/

/**

* 长文本加密

* @param {string} string 待加密长文本

* @returns {string} 加密后的base64编码

* */

JSEncrypt.prototype.encryptLong = function (string) {

var k = this.getKey();

try {

var ct = "";

//RSA每次加密117bytes，需要辅助方法判断字符串截取位置

//1.获取字符串截取点

var bytes = new Array();

bytes.push(0);

var byteNo = 0;

var len, c;

len = string.length;

var temp = 0;

for (var i = 0; i < len; i++) {

c = string.charCodeAt(i);

if (c >= 0x010000 && c <= 0x10FFFF) { //特殊字符，如Ř，Ţ

byteNo += 4;

} else if (c >= 0x000800 && c <= 0x00FFFF) { //中文以及标点符号

byteNo += 3;

} else if (c >= 0x000080 && c <= 0x0007FF) { //特殊字符，如È，Ò

byteNo += 2;

} else { // 英文以及标点符号

byteNo += 1;

}

if ((byteNo % 117) >= 114 || (byteNo % 117) == 0) {

if (byteNo - temp >= 114) {

bytes.push(i);

temp = byteNo;

}

}

}

//2.截取字符串并分段加密

if (bytes.length > 1) {

for (var i = 0; i < bytes.length - 1; i++) {

var str;

if (i == 0) {

str = string.substring(0, bytes[i + 1] + 1);

} else {

str = string.substring(bytes[i] + 1, bytes[i + 1] + 1);

}

var t1 = k.encrypt(str);

ct += t1;

}

;

if (bytes[bytes.length - 1] != string.length - 1) {

var lastStr = string.substring(bytes[bytes.length - 1] + 1);

ct += k.encrypt(lastStr);

}

return hex2b64(ct);

}

var t = k.encrypt(string);

var y = hex2b64(t);

return y;

} catch (ex) {

console.log(ex);

return false;

}

};

/**

* 长文本解密

* @param {string} string 加密后的base64编码

* @returns {string} 解密后的原文

* */

JSEncrypt.prototype.decryptLong = function (string) {

var k = this.getKey();

var maxLength = 128;

try {

var string = b64tohex(string);

var ct = "";

if (string.length > maxLength * 2) {

var lt = string.match(/.{1,256}/g); //128位解密。取256位

lt.forEach(function (entry) {

var t1 = k.decrypt(entry);

ct += t1;

});

return ct;

}

var y = k.decrypt(string);

return y;

} catch (ex) {

return false;

}

};

function hex2b64(h) {

var b64map="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

var b64padchar="=";

var i;

var c;

var ret = "";

for(i = 0; i+3 <= h.length; i+=3) {

c = parseInt(h.substring(i,i+3),16);

ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63);

}

if(i+1 == h.length) {

c = parseInt(h.substring(i,i+1),16);

ret += b64map.charAt(c << 2);

}

else if(i+2 == h.length) {

c = parseInt(h.substring(i,i+2),16);

ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);

}

while((ret.length & 3) > 0) ret += b64padchar;

return ret;

}

一个简单的测试页面，就不做前后台衔接了，只是在前提用后台生成的公钥进行加密，然后后台main方法解密一下。

MyHtml.html

$(function() {

$('#submit').click(function() {

var data = $('#msg').val();

// 公钥

var publickey = $('#publickey').val();

// 使用jsencrypt库加密前端参数

var jsencrypt = new JSEncrypt();

jsencrypt.setPublicKey(publickey);

// 这里调用长文本的加密方法

var ecodeMsg = jsencrypt.encryptLong(data);

$('#ecodeMsg').val(ecodeMsg);

});

});

需要加密的内容:

公钥:

密文:

上海积分吴老师
关注
java发送加密报文_RSA加密---从后台到客户端实现报文加解密
weixin_30475939的博客
02-28 1189
RSA是当前最流行的非对称加密方式，使用公钥加密使用密钥解密，如何妥善的保管密钥就成了关键。动态生成密钥工具类package com.yitong.utils;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security....
JS客户端RSA加密，Java服务端解密（含分段加解密）
jxlxx_023的博客
07-20 996
java代码依赖 <dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> <version>1.4</version> <scope>...
java 客户端和服务端加密_客户端的Java加密和服务器的解密，使用PBKDF2WithHmacSHA1和AES/CBC/PKCS5Padding...
weixin_42362931的博客
02-24 611
只要私钥保密，并且在解密时我的应用中出现以下错误：javax.crypto.BadPaddingException：给定的最终块未正确填充代码：// Encryption, client sidebyte[] plainData = "hello plaintext!".getBytes("UTF-8");byte[] salt = new byte[64];new SecureRandom()....
Spring Boot 接口数据加解密，太方便了！
最新发布
码猿技术专栏
09-27 263
大家好，我是不才陈某~今天这篇文章聊一聊接口安全问题，涉及到接口的加密、解密和产品、前端同学对外需求后，梳理了相关技术方案， 主要的需求点如下：尽量少改动，不影响之前的业务逻辑；考虑到时间紧迫性，可采用对称性加密方式，服务需要对接安卓、IOS、H5三端，另外考虑到H5端存储密钥安全性相对来说会低一些，故分针对H5和安卓、IOS分配两套密钥；要兼容低版本的接口，后面新开发的接口可不用兼容；接口有GE...
java 客户端和服务端加密_实现客户端加密，后台解密
weixin_26820341的博客
02-13 1015
项目要求对数据传输进行加密，即在客户端未提交的时候进行加密，到后台服务器端进行解密，也就是要求用脚本加密，java解密或者java加密，脚本解密，在网上找了许久，只找到了单纯一种语言的加密解密，不是脚本就是java的，于是下载一个脚本加解密程序，改写成java的，算法一样所以就实现了前后台的加密。贴出来供大家参考。脚本encrypt.jsvar g_keyOut=new Array(768);va...
Android+Java后端数据交互加密——AES+RSA
优了个秀
10-26 1977
早前公司新开发了个项目，在数据加密部分讨论后选择了AES+RSA方式（对称+非对称）。参考了网上部分比较优秀的例子后，最终使用了一下实现方式，有需要的朋友可以在文章的最后获取完整demo。话不多说，直接开始。 下面会先简单介绍加解密思路，然后再分别介绍Java后端和Android端的实现，最后再简单搭建个环境实现两端数据加解密。 加密解密流程 一、加密： 1、客户端和服务端双方约定好公私钥对，即公钥PUBLIC_KEY，私钥PRIVATE_KEY 2、客户端使用私钥PRIVATE_KEY对数
java 客户端和服务端加密_JS客户端RSA加密，Java服务端解密
weixin_42613583的博客
02-24 233
java代码依赖commons-codeccommons-codec1.4compileorg.bouncycastlebcprov-jdk15on1.52js代码依赖jsencrypt.js1.[文件] jsencrypt.js~131KB 下载(907)2.[代码][JavaScript]代码// java后台生成的var publicKey = "MIGfMA0GCSqGSIb3...
RSA加密解密 JS加密 JAVA解密 【完美版】
12-12
经过本人修改，简化并完善了别人的代码，使其更加的容易理解和学习！ 此为一个完整的项目，...功能：服务端随机生成密钥，JS用公钥加密，服务端用私钥解密。用到的JS加密文件是从官网下载的最新版，速度快，稳定性好！
RSA加密 js客户端加密 java服务端servlet解密
12-05
Java提供了强大的Java Cryptography Architecture (JCA) 和Java Cryptography Extension (JCE)，它们包含了处理RSA加密解密的类和接口，如`java.security.KeyPairGenerator`用于生成密钥对，`javax.crypto.Cipher`...
JS客户端RSA加密，Java服务端解密
05-01
JavaScript客户端RSA加密与Java服务端解密是一种常见的安全通信机制，尤其在Web应用中，用于保护敏感数据，如用户密码、API密钥等。这里我们将深入探讨这一过程，包括RSA算法的基本原理，JavaScript中的实现，以及...
flutter加密java解密
02-23
在Flutter和Java混合开发的场景中，"flutter加密java解密"的主题涉及到如何在Flutter客户端与Java后台之间进行安全的数据交互，确保信息在传输过程中不被窃取或篡改。这里我们将详细讨论如何实现这一目标，并保证App...
JavaScript-RSA加解密
08-10
RSA前端加解密。是通过用jsencrypt.min.js来实现的，支持超长文本加解密。亲测可用。
客户端加密服务器端解密文件,RSA（客户端加密/服务器解密）
weixin_30539317的博客
08-11 704
这是此question项目的延续，但没有Bouncy城​​堡。所以我决定废弃Bouncy Castle(可惜，我喜欢这个名字)ANYWAY我有一台服务器和一台客户端。客户端需要将序列化对象发送到服务器，然后服务器将处理该对象。这样做，但是我想在流程中添加加密功能。但是没有存储文件或类似的东西。该过程需要基于会话(在某种意义上)因此，客户端将从服务器请求密钥，服务器将生成密钥对并将密钥发送给客户端。...
java jcryption_客户端JavaScript加密数据，服务端Java解密数据
weixin_39906192的博客
02-16 357
原文：http://blog.csdn.net/peterwanghao/article/details/43303807在普通的页面提交时，如果没有使用SSL，提交的数据将使用纯文本的方式发送。如果使用抓包工具可以轻易地截获一些关键数据。jCryption是一个jQuery插件，能够加密由Forms提交的POST/GET数据。官网地址：http://www.jcryption.org/未加密处理...
Android客户端与java服务端AES加解密
yshr1991的博客
05-04 1587
AES加密分两大块来说吧（仅在客户端加解密和客户端加密服务端解密）, （一）针对于android客户端加解密来说，比如登陆时候将用户名和密码存储到sharedpreferences 中对于解密位数没有要求，8位、16位、32位都可以成功加解密代码如下（可以直接作为一个utils封装成一个jar来调用）：（二） public class AESUtil {    public static S
客户端信息MD5加密并传递参数给服务器端
u011194983的专栏
10-08 1964
客户端信息MD5加密并传递参数给服务器端 即：JSP页面中通过JS进行MD5加密传值。   1. 将md5.js文件放入WebRoot下。 2. 在JSP页面调用这个JS，即添加语句： 3. form框如下设置(举创建用户的例子说明)：      创建名称:        创建密码:        确认密码:            
security.js RSA加密与java客户端解密
whm_14718105113的博客
03-31 796
在通常的http协议的网站中直接提交数据可以通过信息抓取从而暴露提交者所提交的信息，特别是注册时的密码和登录时的密码容易被泄露。那么怎么防止这种现象呢？很多人会想到加密技术，对没错，本文所讲的就是使用rsa非对称加密技术进行数据提交，由客户获取后台所产生的公钥对提交字段进行加密，用户提交后再由后台所产生的私钥进行解密。这里以用户登录时对用户密码进行加密为列，下面直接上代码： 前端js代码： &l...
RSA加密算法-前台JS加密-后台java解密
呼吸的小鱼博客
12-18 923
1、前台使用jsencrypt的RSA加密： https://github.com/travist/jsencrypt/tree/v2.3.0 2、后台使用java解密-包括生成公钥和密钥 package com.hand.hdmp.core.util; import java.io.ByteArrayOutputStream; import java.math.BigInteger; i...
web页面使用js加密敏感信息，java端解密
zqz_zqz的博客
09-03 4507
为了保证安全，现在web应用中，大部分都使用https了，但是https只对传输通道进行加密，一旦通道被破，明文数据就被攻击者获取了，为了保证数据传输过程中的安全性，需要对敏感数据传输前做一次加密，下面演示如何通过RSA加密，做到前后端数据的安全传输： 首先我们需要一个前端js加密工具，这个工具叫JSEncrypt， 官方主页：http://travistidwell.com/jsencryp...
JAVA RSA解密JS加密实战指南
1. 导入必要的库：`Commons Codec` 包中的 `Base64` 类用于处理Base64编码，`Cipher` 和其他 `javax.crypto` 类用于执行RSA加密/解密，`java.security` 包中的类用于生成和操作密钥对。 2. 在 `RSACoder` 类中定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值