RSA算法 JS加密 JAVA解密
Java加密与解密方法详解
Java加密与解密方法详解1. 引言在当今数字化时代,保护数据的安全性成为了一项重要的任务。
无论是在个人使用还是企业应用中,数据的加密和解密都是必不可少的环节。
而Java作为一门广泛应用于软件开发的编程语言,其提供了丰富的加密和解密方法,本文将对Java中的加密与解密方法进行详细的介绍和分析。
2. 对称加密算法对称加密算法是指加密和解密使用相同的密钥的算法。
Java中常用的对称加密算法有DES、AES等。
其中,DES是一种较早期的对称加密算法,它使用56位的密钥对数据进行加密和解密。
而AES是一种更加安全和高效的对称加密算法,它使用128位、192位或256位的密钥对数据进行加密和解密。
在Java中,使用对称加密算法进行加密和解密的步骤如下:(1)生成密钥:通过密钥生成器(KeyGenerator)生成一个密钥(Key)。
(2)初始化加密/解密器:通过Cipher类的getInstance方法获取加密/解密器,并设置加密/解密模式和密钥。
(3)加密/解密数据:调用加密/解密器的方法对数据进行加密/解密操作。
3. 非对称加密算法非对称加密算法是指加密和解密使用不同的密钥的算法。
Java中常用的非对称加密算法有RSA、DSA等。
其中,RSA是一种基于大数因子分解的非对称加密算法,它使用公钥和私钥对数据进行加密和解密。
在Java中,使用非对称加密算法进行加密和解密的步骤如下:(1)生成密钥对:通过密钥对生成器(KeyPairGenerator)生成一个密钥对(KeyPair)。
(2)获取公钥和私钥:通过密钥对获取公钥和私钥。
(3)初始化加密/解密器:通过Cipher类的getInstance方法获取加密/解密器,并设置加密/解密模式和密钥。
(4)加密/解密数据:调用加密/解密器的方法对数据进行加密/解密操作。
4. 哈希算法哈希算法是一种将任意长度的数据映射为固定长度的数据的算法。
Java中常用的哈希算法有MD5、SHA-1、SHA-256等。
java中rsa加密原理
java中rsa加密原理
RSA(Rivest-Shamir-Adleman)是一种非对称加密算法,它使用一对密钥来进行加密和解密操作。
在Java中实现RSA加密的原理主要包括以下几个步骤:
1. 密钥生成:RSA算法需要一对密钥,包括一个公钥和一个私钥。
公钥用于加密数据,私钥用于解密数据。
密钥对是通过随机数生成器来生成的,私钥作为随机数的一部分,用于生成公钥。
在Java中,可以使用Java Cryptography Extension (JCE)来实现密钥对的生成。
2. 加密过程:加密过程使用公钥对数据进行加密。
RSA加密的基本原理是将明文数据按照一定的规则进行分组,然后使用公钥对每个分组进行加密。
加密的过程可以看作是使用公钥对每个分组进行一系列数学运算,最终得到密文数据。
在Java中,可以使用Java Cryptography Extension (JCE)提供的RSA加密方法来执行加密操作。
3. 解密过程:解密过程使用私钥对密文数据进行解密。
解密的过程可以看作是使用私钥对每个分组进行一系列数学运算,最终得到明文数据。
在Java 中,可以使用Java Cryptography Extension (JCE)提供的RSA解密方法来执行解密操作。
需要注意的是,由于RSA算法涉及到大量的数学运算和数据分组,因此在实际应用中需要考虑到性能和安全性的问题。
此外,RSA算法还涉及到证书和签名等安全机制,因此在实现过程中需要考虑到这些因素。
java后台加密解密方法
java后台加密解密方法一、加密方法1. 加密算法在Java后台中,常用的加密算法有AES、DES、RSA等。
其中,AES算法是一种对称加密算法,具有较高的安全性和可靠性;DES算法是一种对称分组加密算法,虽然安全性稍逊于AES,但在实际应用中仍然具有一定的安全性;RSA算法是一种非对称加密算法,需要使用私钥和公钥对数据进行加密和解密,适用于数字签名和身份认证等场景。
2. 加密工具在Java中,常用的加密工具包括Java Cryptography Extension (JCE)、Apache Commons Codec等。
JCE提供了各种加密算法的实现,方便开发者使用;Apache Commons Codec则提供了一系列的加密和解密方法,如Base64、Hex、Sha1等。
3. 加密过程加密过程包括数据加密和数据传输加密两个环节。
在数据加密环节,需要根据具体的应用场景选择合适的加密算法和密钥,并将明文数据经过加密算法处理成密文数据。
在数据传输过程中,为了保证数据的安全性,需要使用传输加密算法对数据进行加密,确保数据在传输过程中的安全性。
以下是一个使用AES算法进行数据加密的示例代码:```javaimport javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;public class AESEncryptor {private static final String SECRET_KEY = "1234567890123456"; // 密钥private static final String ALGORITHM = "AES"; // 加密算法public static String encrypt(String strToEncrypt) {try {Cipher cipher = Cipher.getInstance(ALGORITHM);SecretKeySpec secretKeySpec = new SecretKeySpec(SECRET_KEY.getBytes(), ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);byte[] encryptedByte =cipher.doFinal(strToEncrypt.getBytes());returnBase64.getEncoder().encodeToString(encryptedByte);} catch (Exception e) {e.printStackTrace();}return null;}}```在上述代码中,我们使用AES算法对字符串进行加密,并将加密后的结果使用Base64编码进行输出。
rsa公钥解密javascript方法
rsa公钥解密javascript方法
RSA(Rivest–Shamir–Adleman)是一种非对称加密算法,其中涉及公钥和私钥的使用。
公钥用于加密数据,而私钥用于解密数据。
然而,重要的是要理解,虽然公钥可以用于加密数据,但它不能用于解密数据。
解密RSA 加密的数据需要使用相应的私钥。
在JavaScript中,你通常会使用像node-rsa或jsencrypt这样的库来处理RSA加密和解密,因为直接处理大数的运算(这是RSA加密的基础)可能很复杂,而且容易出错。
这些库为我们处理了所有的底层数学运算,让我们能够简单地使用RSA。
如果你想在JavaScript中解密由RSA公钥加密的数据,这通常意味着你有一个误解。
你应该使用私钥来解密数据。
下面是一个使用node-rsa库进行RSA解密的示例:
首先,你需要安装node-rsa库:
然后,你可以使用以下代码进行解密:
请注意,上述代码中的key是一个私钥实例。
如果你尝试使用公钥实例来解密数据,它将失败,因为公钥不能用于解密。
总之,虽然RSA公钥加密的数据可以使用任何相应的公钥来解密,但私钥加密的数据只能使用相应的私钥来解密。
如果你尝试使用公钥来解密私钥加密的数据,你会得到一个错误,因为这不是RSA加密的工作原理。
java加密之RSA算法加密与解密的实例详解
java加密之RSA算法加密与解密的实例详解java 加密之RSA算法加解密与解密的实例详解前⾔:RSA是第⼀个⽐较完善的公开密钥算法,它既能⽤于加密,也能⽤于数字签名。
RSA以它的三个发明者Ron Rivest, Adi Shamir, Leonard Adleman的名字⾸字母命名,这个算法经受住了多年深⼊的密码分析,虽然密码分析者既不能证明也不能否定RSA的安全性,但这恰恰说明该算法有⼀定的可信性,⽬前它已经成为最流⾏的公开密钥算法。
RSA的安全基于⼤数分解的难度。
其公钥和私钥是⼀对⼤素数(100到200位⼗进制数或更⼤)的函数。
从⼀个公钥和密⽂恢复出明⽂的难度,等价于分解两个⼤素数之积(这是公认的数学难题)。
RSA加密与解密RSA算法的密钥由公钥和私钥组成,公钥⽤于加密,私钥⽤于解密。
顾名思义,公钥就是可以进⾏公开的密钥,⼀般可以公开给你的合作伙伴;私钥就是私有的,也就是只有你知道的,你的合作伙伴通过你提供的公钥进⾏加密的内容只有你能进⾏解密,这样也就只有你知道他发的是什么内容。
⽤于加密的公钥和私钥是配对的。
这样的⼀对密钥在Java中由java.security.KeyPairGenerator来产⽣。
以下是⼀个⽣成密钥对的⽰例,该⽰例中还将⽣成的密钥对分别保存到了⽂件中。
private static final String ALGORITHM = "RSA";private static final String PRIVATE_KEY_PATH = "D:\\rsa_private.isa";private static final String PUBLIC_KEY_PATH = "D:\\rsa_public.isa";/*** ⽣成公钥和私钥并存储到⽂件中* @throws Exception*/@Testpublic void geneKeyPair() throws Exception {KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);keyPairGenerator.initialize(1024);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();//私钥PublicKey publicKey = keyPair.getPublic();//公钥byte[] privateKeyBytes = privateKey.getEncoded();//私钥对应的字节数组byte[] publicKeyBytes = publicKey.getEncoded();//公钥对应的字节数组Files.write(Paths.get(PRIVATE_KEY_PATH), privateKeyBytes);Files.write(Paths.get(PUBLIC_KEY_PATH), publicKeyBytes);}加密加密的过程跟使⽤AES算法进⾏加密的过程类似,唯⼀需要注意的是使⽤存储起来的公钥时需要使⽤X509EncodedKeySpec 进⾏封装,然后通过KeyFactory.generatePublic(KeySpec)进⾏⽣成。
java rsa加密算法原理
java rsa加密算法原理
Java RSA是一种非对称加密算法,它是目前广泛使用的公钥加密算法之一,RSA算法基于大数因子分解的数学难题,加密算法原理:
1.随机选择两个不同的大素数p和q,计算n=p*q,n被称为模数。
2.计算欧拉函数φ(n)=(p-1)*(q-1)。
3.选择一个小于φ(n)且与φ(n)互质的整数e,e被称为公钥指数。
4.计算满足以下条件的整数d,d被称为私钥指数,公钥由(n,e)组成,私钥由
(n,d)组成。
5.加密时,将明文m转换为整数M,然后使用公式C=M^e mod n对明文进
行加密,得到密文C。
6.解密时,使用私钥指数d,对密文C进行解密得到明文M,再将M转换为
明文m。
RSA算法的安全性基于大素数因子分解问题的难度,即找到n的两个大素数因子p和q。
当前,只要使用足够大的密钥长度,如2048位或以上,RSA算法被认为是安全的。
RSA算法不仅可以用于加密和解密数据,还可以用于数字签名、密钥协商和密钥交换等密码学应用。
java相关加密解密方法
java相关加密解密方法Java加密解密方法是保护数据安全的重要手段,本文将详细介绍几种常见的Java加密解密方法。
一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。
这种加密方式简单高效,但存在密钥管理的问题,因为所有用户都必须知道密钥。
在Java中,常用的对称加密算法有DES、3DES、AES等。
1. DES:Data Encryption Standard,数据加密标准,是一种使用56位密钥的对称块密码算法。
在Java中,我们可以使用javax.crypto.Cipher类来实现DES 加密解密。
2. 3DES:Triple Data Encryption Algorithm,三重数据加密算法,是DES的增强版本,使用三个不同的56位密钥进行三次加密。
在Java中,我们同样可以使用Cipher类来实现3DES加密解密。
3. AES:Advanced Encryption Standard,高级加密标准,是一种使用128、192或256位密钥的对称块密码算法。
在Java中,我们可以使用Cipher类来实现AES加密解密。
二、非对称加密算法非对称加密算法是一种使用一对密钥(公钥和私钥)进行加密和解密的算法。
公钥可以公开给所有人,而私钥需要保密。
在Java中,常用的非对称加密算法有RSA、DSA等。
1. RSA:Rivest-Shamir-Adleman,一种基于大数因子分解难题的非对称加密算法。
在Java中,我们可以使用java.security.KeyPairGenerator类生成RSA密钥对,然后使用Cipher类进行RSA加密解密。
2. DSA:Digital Signature Algorithm,数字签名算法,是一种基于整数有限域离散对数难题的非对称加密算法。
在Java中,我们可以使用KeyPairGenerator类生成DSA密钥对,然后使用Signature类进行DSA签名和验证。
java后台加密解密方法
java后台加密解密方法Java后台加密解密方法在当今互联网安全领域中具有重要意义。
为了保护数据的安全,各种加密算法应运而生。
本文将介绍几种常见的Java后台加密解密方法,包括RSA、AES、DES和SM2。
1.RSA加密解密原理及实现RSA是一种非对称加密算法,其公钥和私钥是成对存在的。
使用公钥加密后的数据只能通过私钥进行解密。
在Java中,我们可以使用KeyPairGenerator生成一对公私钥,然后使用RSAPrivateKey对数据进行解密。
2.AES加密解密原理及实现AES是一种对称加密算法,加密和解密过程使用相同的密钥。
在Java中,我们可以使用Java的加密库如Java Cryptography Extension (JCE)实现AES 加密解密。
3.DES加密解密原理及实现DES是一种对称加密算法,其加密过程和解密过程使用不同的密钥。
在Java中,我们可以使用Java Cryptography Extension (JCE)实现DES加密解密。
4.SM2加密解密原理及实现SM2是一种国密算法,具有非对称加密和对称加密的特点。
在前端,我们可以使用SM2加密请求参数,然后在后台使用对应的私钥进行解密。
在Java 中,我们可以使用Hutool库实现SM2加密解密。
5.总结:选择合适的加密解密方法及注意事项在实际应用中,选择合适的加密解密方法至关重要。
需要考虑数据安全性、算法复杂度、性能和兼容性等因素。
此外,还需注意以下几点:- 加密解密算法应根据实际需求进行选择,如对称加密算法适用于加密大量数据,非对称加密算法适用于加密少量数据;- 加密密钥和解密密钥应妥善保管,避免泄露;- 在传输加密数据时,应注意防范中间人攻击,可以使用SSL/TLS等安全协议进行保护;- 定期更新和升级加密算法,以应对潜在的安全威胁。
本文介绍了Java后台加密解密方法,包括RSA、AES、DES和SM2。
用javascript与java进行RSA加密与解密
用javascript与java进行RSA加密与解密用javascript与java进行RSA加密与解密具体实现思路如下:1。
服务端生成公钥与私钥,保存。
2。
客户端在请求到登录页面后,随机生成一字符串。
3。
后此随机字符串作为密钥加密密码,再用从服务端获取到的公钥加密生成的随机字符串。
4。
将此两段密文传入服务端,服务端用私钥解出随机字符串,再用此私钥解出加密的密文。
这其中有一个关键是解决服务端的公钥,传入客户端,客户端用此公钥加密字符串后,后又能在服务端用私钥解出。
此文即为实现此步而作。
加密算法为RSA:1。
服务端的RSA java实现。
Java代码package com.castscs.util;import java.io.ByteArrayOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.math.BigInteger;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;import java.security.PrivateKey;import java.security.PublicKey;import java.security.SecureRandom;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.InvalidKeySpecException;import java.security.spec.RSAPrivateKeySpec;import java.security.spec.RSAPublicKeySpec;import javax.crypto.Cipher;/*** RSA 工具类。
java rsa加密解密实例
java rsa加密解密实例这是一个使用Java进行RSA加密和解密的简单示例。
这个示例使用了Java的内置加密库,并且只适用于小数据块的加密和解密。
对于大数据块,你可能需要使用一种称为"混合加密"的技术,将数据分成小块并分别加密。
首先,我们需要导入一些必要的库:```javaimport ;import ;import ;```然后,我们可以生成RSA密钥对:```javaKeyPairGenerator keyGen = ("RSA");(2048);KeyPair pair = ();PrivateKey privateKey = ();PublicKey publicKey = ();```接下来,我们可以使用公钥进行加密,然后使用私钥进行解密。
首先,我们创建一个Cipher对象用于加密:```javaCipher encryptCipher = ("RSA");(_MODE, publicKey);byte[] cipherText = ("Hello, World!".getBytes());String cipherTextBase64 = ().encodeToString(cipherText);```然后,我们创建一个Cipher对象用于解密:```javaCipher decryptCipher = ("RSA");(_MODE, privateKey);byte[] plainText = (().decode(cipherTextBase64));String plainTextStr = new String(plainText);```现在,`plainTextStr`就是解密后的原始文本。
注意,这个例子中的数据是硬编码的,并且只包含英文字符。
如果你的数据包含其他字符(例如中文字符),或者你需要处理的数据量很大,你可能需要使用不同的方法。
Java应用开发中的数据加密和解密技术
Java应用开发中的数据加密和解密技术在当今信息时代,数据安全问题日益凸显,各种数据泄露事件频频发生。
为了保护用户的隐私和数据安全,数据加密和解密技术在Java应用开发中扮演着至关重要的角色。
本文将探讨Java应用开发中常用的数据加密和解密技术及其应用。
一、对称加密算法对称加密算法是一种使用相同密钥进行加密和解密的算法。
在Java应用开发中,常用的对称加密算法有DES、AES等。
它们通过使用相同的密钥对数据进行加密和解密,速度较快,适用于大数据量的加密。
1.1 DES算法DES(Data Encryption Standard)是一种对称加密算法,采用分组密码体制,每次只能处理64位的数据块。
DES算法通过轮代加密将64位明文数据块转换为64位密文数据块,密钥长度为56位,使用的是密钥加密解密相同,密钥长度为64位。
由于DES算法的密钥长度较短,因此安全性相对较低。
1.2 AES算法AES(Advanced Encryption Standard)是一种对称加密算法,可以使用不同的密钥长度(128位、192位和256位)进行数据加密和解密。
AES算法被广泛应用于各种Java应用开发场景中,例如网络传输加密、数据库数据保护等。
AES算法具有较高的安全性和性能,是目前最常用的对称加密算法之一。
二、非对称加密算法非对称加密算法是一种使用公钥和私钥进行加密和解密的算法。
公钥用于加密,私钥用于解密。
在Java应用开发中,常用的非对称加密算法有RSA、DSA等。
非对称加密算法具有较高的安全性,但加密和解密的速度较慢,适用于对安全性要求较高且数据量较小的场景。
2.1 RSA算法RSA算法是一种非对称加密算法,常用于数据加密、数字签名等安全领域。
RSA算法利用大素数的因数分解问题,使得加密方便、解密困难,保证了数据的安全性。
在Java应用开发中,我们可以通过引入第三方库使用RSA算法进行数据的加密和解密。
三、哈希算法哈希算法是一种将数据转换为固定长度的哈希值的算法。
RSAAES前端JS与后台JAVA的加密解密的是实现
RSAAES前端JS与后台JAVA的加密解密的是实现AES CryptoJS前提是编码⽅式,key,vi中设置⼀样,就可以进⾏跨语⾔加密解密<link rel="stylesheet" href="<%=basePath %>/css/login.css"><script src="<%=basePath %>jslib/jquery-1.8.3.js" type="text/javascript" ></script><script src="<%=basePath %>jslib/Common.js" type="text/javascript" ></script><script src="<%=basePath %>jslib/core-min.js" type="text/javascript" ></script><script src="<%=basePath %>jslib/aes.js" type="text/javascript" ></script></head><body><form action="<%=basePath %>login?action=goAES" id="login" name="form" method="post"><h1>Log In</h1><fieldset id="inputs"><input id="name" type="text" placeholder="Username" value="" autofocus required><!-- ming --><input id="pwd" name="pwd" type="password" placeholder="Password" value="" required></fieldset><fieldset id="actions"><input type="button" id="button" onclick="go()" value="登录"><a href="#" id="msg"></a></fieldset><input type="hidden" name="key" id="key"><!-- 密钥 --><input type="hidden" id="msg_source" value="0807060504030201"></form><script type="text/javascript">function go(){if(isEmptyById(['name','pwd'])){$('#msg').text('⽤户名或密码不能为空');return;}//var pwd = $("#pwd").val();//("加密前: "+pwd);//CryptoJS.AES.encrypt('明⽂','key');//var ecodeRestult = CryptoJS.AES.encrypt($("#pwd").val(),$("#msg_source").val());//("加密后:"+ecodeRestult);//$("#pwd").val(ecodeRestult);//CryptoJS.AES.decrypt('密⽂','key').toString(CryptoJS.enc.Utf8);//var decodeResult = CryptoJS.AES.decrypt(ecodeRestult,$("#msg_source").val()).toString(CryptoJS.enc.Utf8);//("解密后:"+decodeResult);var pwd = $("#pwd").val();var key = CryptoJS.enc.Utf8.parse($("#msg_source").val());var iv = CryptoJS.enc.Utf8.parse($("#msg_source").val());var srcs = CryptoJS.enc.Utf8.parse(pwd);var encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv,mode:CryptoJS.mode.CBC});$("#pwd").val(encrypted);$('#login').submit();}</script>这⾥需要注意的是$("#msg_source").val(); 因为key是动态的,需要从服务器提前设置好,前端AES JS加密指定是CryptoJS.mode.CBC模式,那么Java解密的同时也必须⽤这个模式来解密,不然会报错Given final block not properly padded...异常AES--Javapackage mon.kit;import org.apache.log4j.Logger;import javax.crypto.Cipher;import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;import mons.codec.binary.Base64;public class AESKit {/*** Logger for this class*/private static final Logger logger = Logger.getLogger(AESKit.class);public static final String IV = "0807060504030201";/******************************************************************** AES加密算法* @author moyun* 加密⽤的Key 可以⽤26个字母和数字组成,最好不要⽤保留字符,虽然不会错,⾄于怎么裁决,个⼈看情况⽽定此处使⽤AES-128-CBC加密模式,key需要为16位。
RSA加密解密实现(JAVA)
RSA加密解密实现(JAVA)1.关于RSA算法的原理解析参考:2.RSA密钥长度、明⽂长度和密⽂长度参考:3.以下⽰例代码可以将密钥Base64转码之后保存到⽂本⽂件内,也可以从⽂本⽂件中读取密钥。
public class RSAGenerator {/*** 算法*/private String ALGORITHM_RSA = "RSA";private String DEFAULT_ENCODING = "UTF-8";public static final String KEY_TYPE_PUBLIC = "PUBLIC";public static final String KEY_TYPE_PRIVATE = "PRIVATE";/*** 公钥*/private RSAPublicKey publicKey;private String publicKeyStr;/*** 私钥*/private RSAPrivateKey privateKey;private String privateKeyStr;/*** ⽤于加解密*/private Cipher cipher;/*** 明⽂块的长度它必须⼩于密⽂块的长度 - 11*/private int originLength = 128;/*** 密⽂块的长度*/private int encrytLength = 256;/*** ⽣成密钥对* @return*/public RSAGenerator generateKeyPair() {try {// RSA加密算法KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM_RSA);// 创建密钥对,长度采⽤2048keyPairGenerator.initialize(2048);KeyPair keyPair = keyPairGenerator.generateKeyPair();// 分别得到公钥和私钥publicKey = (RSAPublicKey) keyPair.getPublic();privateKey = (RSAPrivateKey) keyPair.getPrivate();// 使⽤ Base64编码publicKeyStr = Base64Util.encode(publicKey.getEncoded());privateKeyStr = Base64Util.encode(privateKey.getEncoded());//将BASE64编码的结果保存到⽂件内String classPath = this.getClass().getClassLoader().getResource("").toString();String prefix = classPath.substring(classPath.indexOf(":") + 1);String publicFilePath = prefix+"public.txt";File publicFile= new File(publicFilePath);saveBase64KeyToFile(publicFile, publicKeyStr);String privateFilePath = prefix+"private.txt";File privateFile= new File(privateFilePath);saveBase64KeyToFile(privateFile, privateKeyStr);} catch (NoSuchAlgorithmException e) {e.printStackTrace();}return this;}/*** ⽤公钥加密* @param content* @return 加密后的16进制字符串*/public String encryptByPublic(String content) {String encode = "";try {cipher = Cipher.getInstance(ALGORITHM_RSA);cipher.init(Cipher.ENCRYPT_MODE, publicKey);// 该密钥能够加密的最⼤字节长度int splitLength = publicKey.getModulus().bitLength() / 8 - 11; byte[][] arrays = splitBytes(content.getBytes(), splitLength); // 加密StringBuffer buffer = new StringBuffer();for (byte[] array : arrays) {buffer.append(bytesToHexString(cipher.doFinal(array)));}encode = buffer.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}return encode;}/*** ⽤私钥加密** @param content* @return 加密后的16进制字符串*/public String encryptByPrivate(String content) {try {Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);cipher.init(Cipher.ENCRYPT_MODE, privateKey);// 该密钥能够加密的最⼤字节长度int splitLength = ((RSAPrivateKey) privateKey).getModulus() .bitLength() / 8 - 11;byte[][] arrays = splitBytes(content.getBytes(), splitLength); StringBuffer stringBuffer = new StringBuffer();for (byte[] array : arrays) {stringBuffer.append(bytesToHexString(cipher.doFinal(array))); }return stringBuffer.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();}return null;}/*** ⽤私钥解密* @param content* @return 解密后的原⽂*/public String decryptByPrivate(String content) {String decode = "";try {cipher = Cipher.getInstance(ALGORITHM_RSA);cipher.init(Cipher.DECRYPT_MODE, privateKey);// 该密钥能够加密的最⼤字节长度int splitLength = privateKey.getModulus().bitLength() / 8;byte[] contentBytes = hexStringToBytes(content);byte[][] arrays = splitBytes(contentBytes, splitLength);StringBuffer stringBuffer = new StringBuffer();for (byte[] array : arrays) {stringBuffer.append(new String(cipher.doFinal(array)));}decode = stringBuffer.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}return decode;}/*** ⽤私钥解密** @param content* @return 解密后的原⽂*/public String decryptByPublic(String content) {String decode = "";try {cipher = Cipher.getInstance(ALGORITHM_RSA);cipher.init(Cipher.DECRYPT_MODE, publicKey);// 该密钥能够加密的最⼤字节长度int splitLength = publicKey.getModulus().bitLength() / 8;byte[] contentBytes = hexStringToBytes(content);byte[][] arrays = splitBytes(contentBytes, splitLength);StringBuffer stringBuffer = new StringBuffer();for (byte[] array : arrays) {stringBuffer.append(new String(cipher.doFinal(array)));}decode = stringBuffer.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}return decode;}/*** 根据限定的每组字节长度,将字节数组分组* @param bytes 等待分组的字节组* @param splitLength 每组长度* @return 分组后的字节组*/public static byte[][] splitBytes(byte[] bytes, int splitLength) {// bytes与splitLength的余数int remainder = bytes.length % splitLength;// 数据拆分后的组数,余数不为0时加1int quotient = remainder > 0 ? bytes.length / splitLength + 1: bytes.length / splitLength;byte[][] arrays = new byte[quotient][];byte[] array = null;for (int i = 0; i < quotient; i++) {// 如果是最后⼀组(quotient-1),同时余数不等于0,就将最后⼀组设置为remainder的长度 if (i == quotient - 1 && remainder != 0) {array = new byte[remainder];System.arraycopy(bytes, i * splitLength, array, 0, remainder);} else {array = new byte[splitLength];System.arraycopy(bytes, i * splitLength, array, 0, splitLength);}arrays[i] = array;}return arrays;}/*** 将字节数组转换成16进制字符串* @param bytes 即将转换的数据* @return 16进制字符串*/public static String bytesToHexString(byte[] bytes) {StringBuffer sb = new StringBuffer(bytes.length);String temp = null;for (int i = 0; i < bytes.length; i++) {temp = Integer.toHexString(0xFF & bytes[i]);if (temp.length() < 2) {sb.append(0);}sb.append(temp);}return sb.toString();}/*** 将16进制字符串转换成字节数组** @param hex* 16进制字符串* @return byte[]*/public static byte[] hexStringToBytes(String hex) {int len = (hex.length() / 2);hex = hex.toUpperCase();byte[] result = new byte[len];char[] chars = hex.toCharArray();for (int i = 0; i < len; i++) {int pos = i * 2;result[i] = (byte) (toByte(chars[pos]) << 4 | toByte(chars[pos + 1])); }return result;}/*** 将char转换为byte** @param c* char* @return byte*/private static byte toByte(char c) {return (byte) "0123456789ABCDEF".indexOf(c);}/*** 保存公钥到⽂件** @param file* @return*/public boolean savePublicKey(File file) {return saveKeyToFile(publicKey, file);}/*** 保存私钥到⽂件** @param file* @return*/public boolean savePrivateKey(File file) {return saveKeyToFile(privateKey, file);}/*** 保存密钥到⽂件* @param key 密钥* @param file ⽂件* @return*/private boolean saveKeyToFile(Key key, File file) {boolean result = false;FileOutputStream fos = null;try {fos = new FileOutputStream(file);ObjectOutputStream oos = new ObjectOutputStream(fos);// 公钥默认使⽤的是X.509编码,私钥默认采⽤的是PKCS #8编码byte[] encode = key.getEncoded();// 注意,此处采⽤writeObject⽅法,读取时也要采⽤readObject⽅法oos.writeObject(encode);oos.close();result = true;} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {try {fos.close();} catch (IOException e) {e.printStackTrace();}}return result;}private boolean saveBase64KeyToFile(File file, String key) {boolean result = false;FileOutputStream fos = null;try {fos = new FileOutputStream(file);fos.write(key.getBytes());fos.close();result = true;} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {try {fos.close();} catch (IOException e) {e.printStackTrace();}}return result;}/*** 从BASE64⽂件中读取KEY值* @param fileName* @param keyType*/public void getKeyFromBase64File(String fileName,String keyType) {try {InputStream inputStream = this.getClass().getClassLoader().getResource(fileName).openStream(); ByteArrayOutputStream outStream = new ByteArrayOutputStream();byte[] subByte = new byte[1024];int len = 0;while((len=inputStream.read(subByte))>0) {outStream.write(subByte,0,len);}inputStream.close();outStream.close();String base64Key = new String(outStream.toByteArray(), DEFAULT_ENCODING);byte[] keybyte = Base64Util.decode(base64Key);// 默认编码KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);if (KEY_TYPE_PUBLIC.equals(keyType)) {X509EncodedKeySpec x509eks = new X509EncodedKeySpec(keybyte);publicKey = (RSAPublicKey) keyFactory.generatePublic(x509eks);System.out.println(publicKey.getAlgorithm());} else {PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);privateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8eks);}} catch (IOException e) {e.printStackTrace();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (InvalidKeySpecException e) {e.printStackTrace();}/*** 从⽂件中得到公钥** @param file*/public void getPublicKey(File file) {getKey(file, KEY_TYPE_PUBLIC);}/*** 从⽂件中得到私钥** @param file*/public void getPrivateKey(File file) {getKey(file, KEY_TYPE_PRIVATE);}/*** 从⽂件中得到密钥** @param file* @param keyType*/private void getKey(File file, String keyType) {FileInputStream fis = null;try {fis = new FileInputStream(file);ObjectInputStream ois = new ObjectInputStream(fis);byte[] keybyte = (byte[]) ois.readObject();// 关闭资源ois.close();// 默认编码KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);if (KEY_TYPE_PUBLIC.equals(keyType)) {X509EncodedKeySpec x509eks = new X509EncodedKeySpec(keybyte);publicKey = (RSAPublicKey) keyFactory.generatePublic(x509eks);System.out.println(publicKey.getAlgorithm());} else {PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);privateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8eks);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (InvalidKeySpecException e) {e.printStackTrace();} finally {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} 代码中涉及到的Base64Util如下:public class Base64Util{private static final char S_BASE64CHAR[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b','c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p','q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3','4', '5', '6', '7', '8', '9', '+', '/' };private static final byte S_DECODETABLE[];static{S_DECODETABLE = new byte[128];for (int i = 0; i < S_DECODETABLE.length; i++)S_DECODETABLE[i] = 127;for (int i = 0; i < S_BASE64CHAR.length; i++)S_DECODETABLE[S_BASE64CHAR[i]] = (byte) i;}/**** @param ibuf* @param obuf* @param wp* @return*/private static int decode0(char ibuf[], byte obuf[], int wp){int outlen = 3;if (ibuf[3] == '=')outlen = 2;if (ibuf[2] == '=')outlen = 1;int b0 = S_DECODETABLE[ibuf[0]];int b1 = S_DECODETABLE[ibuf[1]];int b2 = S_DECODETABLE[ibuf[2]];int b3 = S_DECODETABLE[ibuf[3]];switch (outlen){case 1: // '\001'obuf[wp] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);return 1;case 2: // '\002'obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);obuf[wp] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);return 2;case 3: // '\003'obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);obuf[wp++] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);obuf[wp] = (byte) (b2 << 6 & 192 | b3 & 63);return 3;}throw new RuntimeException("Internal error");}/**** @param data* @param off* @param len* @return*/public static byte[] decode(char data[], int off, int len){char ibuf[] = new char[4];int ibufcount = 0;byte obuf[] = new byte[(len / 4) * 3 + 3];int obufcount = 0;for (int i = off; i < off + len; i++){char ch = data[i];if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127)) continue;ibuf[ibufcount++] = ch;if (ibufcount == ibuf.length){ibufcount = 0;obufcount += decode0(ibuf, obuf, obufcount);}}if (obufcount == obuf.length){return obuf;}else{byte ret[] = new byte[obufcount];System.arraycopy(obuf, 0, ret, 0, obufcount);return ret;}}/**** @param data* @return*/public static byte[] decode(String data){char ibuf[] = new char[4];int ibufcount = 0;byte obuf[] = new byte[(data.length() / 4) * 3 + 3];int obufcount = 0;for (int i = 0; i < data.length(); i++){char ch = data.charAt(i);if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))continue;ibuf[ibufcount++] = ch;if (ibufcount == ibuf.length){ibufcount = 0;obufcount += decode0(ibuf, obuf, obufcount);}}if (obufcount == obuf.length){return obuf;}else{byte ret[] = new byte[obufcount];System.arraycopy(obuf, 0, ret, 0, obufcount);return ret;}}/**** @param data* @param off* @param len* @param ostream* @throws IOException*/public static void decode(char data[], int off, int len, OutputStream ostream) throws IOException {char ibuf[] = new char[4];int ibufcount = 0;byte obuf[] = new byte[3];for (int i = off; i < off + len; i++){char ch = data[i];if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))continue;ibuf[ibufcount++] = ch;if (ibufcount == ibuf.length){ibufcount = 0;int obufcount = decode0(ibuf, obuf, 0);ostream.write(obuf, 0, obufcount);}}}/**** @param data* @param ostream* @throws IOException*/public static void decode(String data, OutputStream ostream) throws IOException{char ibuf[] = new char[4];int ibufcount = 0;byte obuf[] = new byte[3];for (int i = 0; i < data.length(); i++){char ch = data.charAt(i);if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))continue;ibuf[ibufcount++] = ch;if (ibufcount == ibuf.length){ibufcount = 0;int obufcount = decode0(ibuf, obuf, 0);ostream.write(obuf, 0, obufcount);}}}/**** @param data* @return*/public static String encode(byte data[]){return encode(data, 0, data.length);}/**** @param data* @param off* @param len* @return*/public static String encode(byte data[], int off, int len){if (len <= 0)return "";char out[] = new char[(len / 3) * 4 + 4];int rindex = off;int windex = 0;int rest;for (rest = len - off; rest >= 3; rest -= 3){int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255); out[windex++] = S_BASE64CHAR[i >> 18];out[windex++] = S_BASE64CHAR[i >> 12 & 63];out[windex++] = S_BASE64CHAR[i >> 6 & 63];out[windex++] = S_BASE64CHAR[i & 63];rindex += 3;}if (rest == 1){int i = data[rindex] & 255;out[windex++] = S_BASE64CHAR[i >> 2];out[windex++] = S_BASE64CHAR[i << 4 & 63];out[windex++] = '=';out[windex++] = '=';}else if (rest == 2){int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);out[windex++] = S_BASE64CHAR[i >> 10];out[windex++] = S_BASE64CHAR[i >> 4 & 63];out[windex++] = S_BASE64CHAR[i << 2 & 63];out[windex++] = '=';}return new String(out, 0, windex);}/**** @param data* @param off* @param len* @param ostream* @throws IOException*/public static void encode(byte data[], int off, int len, OutputStream ostream) throws IOException{if (len <= 0)return;byte out[] = new byte[4];int rindex = off;int rest;for (rest = len - off; rest >= 3; rest -= 3){int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255); out[0] = (byte) S_BASE64CHAR[i >> 18];out[1] = (byte) S_BASE64CHAR[i >> 12 & 63];out[2] = (byte) S_BASE64CHAR[i >> 6 & 63];out[3] = (byte) S_BASE64CHAR[i & 63];ostream.write(out, 0, 4);rindex += 3;}if (rest == 1){int i = data[rindex] & 255;out[0] = (byte) S_BASE64CHAR[i >> 2];out[1] = (byte) S_BASE64CHAR[i << 4 & 63];out[2] = 61;out[3] = 61;ostream.write(out, 0, 4);}else if (rest == 2){int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);out[0] = (byte) S_BASE64CHAR[i >> 10];out[1] = (byte) S_BASE64CHAR[i >> 4 & 63];out[2] = (byte) S_BASE64CHAR[i << 2 & 63];out[3] = 61;ostream.write(out, 0, 4);}}/**** @param data* @param off* @param len* @param writer* @throws IOException*/public static void encode(byte data[], int off, int len, Writer writer) throws IOException{if (len <= 0)return;char out[] = new char[4];int rindex = off;int rest = len - off;int output = 0;do{if (rest < 3)break;int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255); out[0] = S_BASE64CHAR[i >> 18];out[1] = S_BASE64CHAR[i >> 12 & 63];out[2] = S_BASE64CHAR[i >> 6 & 63];out[3] = S_BASE64CHAR[i & 63];writer.write(out, 0, 4);rindex += 3;rest -= 3;if ((output += 4) % 76 == 0)writer.write("\n");}while (true);if (rest == 1){int i = data[rindex] & 255;out[0] = S_BASE64CHAR[i >> 2];out[1] = S_BASE64CHAR[i << 4 & 63];out[2] = '=';out[3] = '=';writer.write(out, 0, 4);}else if (rest == 2){int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);out[0] = S_BASE64CHAR[i >> 10];out[1] = S_BASE64CHAR[i >> 4 & 63];out[2] = S_BASE64CHAR[i << 2 & 63];out[3] = '=';writer.write(out, 0, 4);}}}测试类:public class RSATest {@Testpublic void test() {RSAGenerator rsaGenerator = new RSAGenerator().generateKeyPair();String str="数表的质数⼜称素数。
java使用RSA加密方式实现数据加密解密的代码
java使⽤RSA加密⽅式实现数据加密解密的代码RSA的应⽤RSA是⼀种⾮对称加密算法。
现在,很多登陆表单的密码的都采⽤RSA加密,例如京东中的登陆使⽤公钥对密码进⾏加密java使⽤RSA加密⽅式实现数据加密解密,需要⾸先产⽣私钥和公钥测试代码public static void main(String args[]){try {RSADemo rsa=new RSADemo();rsa.generateKey();byte[] data=rsa.encrypt("luanpeng".getBytes());byte[] data1=rsa.decrypt(data);String str=new String(data1);System.out.println(str);} catch (Exception e) {System.out.println(e.toString());}}RSA⼯具类的实现package com.lp.app.safe;import java.security.*;import java.security.interfaces.*;import java.math.*;public class RSADemo {public RSADemo() {}PublicKey pbkey;PrivateKey prkey;public void generateKey() {try {KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");kpg.initialize(1024);KeyPair kp = kpg.genKeyPair();pbkey = kp.getPublic();prkey = kp.getPrivate();} catch (Exception e) {}}//加密,需要公钥public byte[] encrypt(byte[] ptext) throws Exception {// 获取公钥及参数e,nRSAPublicKey pbk = (RSAPublicKey)pbkey;BigInteger e = pbk.getPublicExponent();BigInteger n = pbk.getModulus();// 获取明⽂mBigInteger m = new BigInteger(ptext);// 计算密⽂cBigInteger c = m.modPow(e, n);return c.toByteArray();}//使⽤私钥进⾏解密public byte[] decrypt(byte[] ctext) throws Exception {// 读取密⽂BigInteger c = new BigInteger(ctext);// 读取私钥RSAPrivateKey prk = (RSAPrivateKey)prkey;BigInteger d = prk.getPrivateExponent();// 获取私钥参数及解密BigInteger n = prk.getModulus();BigInteger m = c.modPow(d, n);// 显⽰解密结果byte[] mt = m.toByteArray();return mt;}}总结以上所述是⼩编给⼤家介绍的java使⽤RSA加密⽅式实现数据加密解密的代码,希望对⼤家有所帮助,如果⼤家有任何疑问请给我留⾔,⼩编会及时回复⼤家的。
JS七种加密解密方法
JS七种加密解密方法JS中常见的加密解密方法有七种,分别是Base64编码、MD5加密、SHA1加密、AES加密、RSA加密、HMAC加密和URL编码。
一、Base64编码Base64编码示例:```javascriptlet text = 'Hello World!';let encodedText = btoa(text);console.log(encodedText); // "SGVsbG8gV29ybGQh"```Base64解码示例:```javascriptlet encodedText = 'SGVsbG8gV29ybGQh';let decodedText = atob(encodedText);console.log(decodedText); // "Hello World!"```二、MD5加密MD5是一种常用的哈希加密算法,可以将任意长度的数据转换成固定长度的哈希值。
在JS中,可以使用第三方库`crypto-js`来进行MD5加密。
MD5加密示例:```javascriptlet text = 'Hello World!';let encryptedText = CryptoJS.MD5(text).toString(;```三、SHA1加密SHA1也是一种常用的哈希加密算法,可以将任意长度的数据转换成固定长度的哈希值。
在JS中,可以使用第三方库`crypto-js`来进行SHA1加密。
SHA1加密示例:```javascriptlet text = 'Hello World!';let encryptedText = CryptoJS.SHA1(text).toString(;```四、AES加密AES是一种对称加密算法,可以用于加密和解密数据。
在JS中,可以使用第三方库`crypto-js`来进行AES加密。
java语句加密解密案例
java语句加密解密案例Java语言是一种面向对象的编程语言,具有很好的可读性和可维护性。
在实际应用中,我们常常需要对一些敏感信息进行加密和解密,以保证数据的安全性。
本文将以Java语句加密解密案例为题,介绍10个常见的加密解密算法及其实现方法。
一、Caesar加密解密算法Caesar算法是一种简单的替换加密算法,也称为凯撒密码。
它通过将明文中的每个字母按照指定的偏移量进行替换,从而得到密文。
解密过程则是将密文中的每个字母按照相反的偏移量进行替换,恢复成明文。
二、DES加密解密算法DES算法是一种对称密钥加密算法,使用相同的密钥进行加密和解密。
它将明文数据按照固定长度的数据块进行分组,并使用密钥对每个数据块进行加密,最后得到密文。
解密过程则是使用相同的密钥对密文进行解密,恢复成明文。
三、AES加密解密算法AES算法是一种对称密钥加密算法,与DES算法相比,它具有更高的安全性和更快的加解密速度。
AES算法将明文数据按照固定长度的数据块进行分组,并使用密钥对每个数据块进行加密,最后得到密文。
解密过程与加密过程相反,使用相同的密钥对密文进行解密,恢复成明文。
四、RSA加密解密算法RSA算法是一种非对称密钥加密算法,它使用一对密钥,即公钥和私钥。
公钥用于加密数据,私钥用于解密数据。
RSA算法的安全性基于大数分解的难题,即将一个大数分解成两个较小的质数的乘积。
五、哈希算法哈希算法是一种将任意长度的数据映射成固定长度哈希值的算法。
常用的哈希算法有MD5、SHA-1和SHA-256等。
哈希算法通常用于验证数据的完整性,一般不可逆,无法从哈希值恢复出原始数据。
六、Base64编码Base64是一种将二进制数据转换成可打印字符的编码方式。
它将3个字节的数据编码成4个可打印字符,从而减少了数据的长度。
Base64编码通常用于在网络传输中传递二进制数据,如图片、音频等。
七、URL编码URL编码是一种将URL中的特殊字符转换成%加上十六进制表示的字符的过程。
js 加密解密方法
js 加密解密方法JS加密解密方法随着互联网的发展,数据的传输和存储变得越来越重要。
为了保证数据的安全性,人们开始采取各种加密解密方法来保护数据的机密性。
而JavaScript作为一种常用的编程语言,也提供了丰富的加密解密方法供开发者使用。
一、对称加密算法对称加密算法是一种加密解密方式,它使用相同的密钥对数据进行加密和解密。
常见的对称加密算法有DES、AES等。
以AES算法为例,它使用一个密钥对数据进行加密,然后再使用相同的密钥对加密后的数据进行解密。
这种加密解密方式简单、高效,但存在一个问题,就是密钥的安全性,如果密钥泄露,那么加密的数据也就不再安全了。
二、非对称加密算法非对称加密算法使用一对密钥,分别为公钥和私钥。
公钥用于加密数据,私钥用于解密数据。
常见的非对称加密算法有RSA、DSA等。
以RSA算法为例,它是一种基于大素数因子分解的非对称加密算法。
首先生成一对公私钥,将公钥发布给他人,然后他人使用公钥对数据进行加密,然后再使用私钥对加密后的数据进行解密。
这种加密解密方式相对于对称加密算法更加安全,因为私钥只有自己知道,不会泄露给他人。
三、哈希算法哈希算法也被称为散列算法,它可以将输入的任意长度的数据转换为固定长度的哈希值。
常见的哈希算法有MD5、SHA等。
以MD5算法为例,它可以将任意长度的数据转换为128位的哈希值。
哈希算法的特点是不可逆,即无法从哈希值反推出原始数据。
在实际应用中,哈希算法常用于验证数据的完整性,例如文件下载时可以通过比对哈希值来验证文件的完整性。
四、加密解密库除了以上的加密解密算法,还有一些开源的加密解密库可以供开发者使用。
例如crypto-js、jsencrypt等。
这些库提供了丰富的加密解密方法,可以方便地实现各种加密解密需求。
开发者只需要引入相应的库文件,然后调用相应的方法即可实现加密解密功能。
总结起来,JS提供了丰富的加密解密方法,开发者可以根据实际需求选择合适的加密解密算法或库来保护数据的安全性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
RSA算法JS加密JA V A解密有这样一个需求,前端登录的用户名密码,密码必需加密,但不可使用MD5,因为后台要检测密码的复杂度,那么在保证安全的前提下将密码传到后台呢,答案就是使用RSA非对称加密算法解决。
java代码需要依赖commons-codec 包RSACoder.Javaimport mons.codec.binary.Base64;import javax.crypto.Cipher;import java.security.*;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;/*** Created by lake on 17-4-12.*/public class RSACoder {public static final String KEY_ALGORITHM = "RSA";public static final String SIGNA TURE_ALGORITHM = "MD5withRSA";private static final String PUBLIC_KEY = "RSAPublicKey";private static final String PRIV ATE_KEY = "RSAPrivateKey";public static byte[] decryptBASE64(String key) {return Base64.decodeBase64(key);}public static String encryptBASE64(byte[] bytes) {return Base64.encodeBase64String(bytes);}/*** 用私钥对信息生成数字签名** @param data 加密数据* @param privateKey 私钥* @return* @throws Exception*/public static String sign(byte[] data, String privateKey) throws Exception { // 解密由base64编码的私钥byte[] keyBytes = decryptBASE64(privateKey);// 构造PKCS8EncodedKeySpec对象PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);// KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取私钥匙对象PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);// 用私钥对信息生成数字签名Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initSign(priKey);signature.update(data);return encryptBASE64(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 {// 解密由base64编码的公钥byte[] keyBytes = decryptBASE64(publicKey);// 构造X509EncodedKeySpec对象X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);// KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取公钥匙对象PublicKey pubKey = keyFactory.generatePublic(keySpec);Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initVerify(pubKey);signature.update(data);// 验证签名是否正常return signature.verify(decryptBASE64(sign));}public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception{ // 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 解密<br>* 用私钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPrivateKey(String data, String key)throws tion {return decryptByPrivateKey(decryptBASE64(data),key);}/*** 解密<br>* 用公钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPublicKey(byte[] data, String key)throws Exception {// 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, publicKey);return cipher.doFinal(data);}/*** 加密<br>* 用公钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPublicKey(String data, String key)throws Exception {// 对公钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, publicKey);return cipher.doFinal(data.getBytes());}/*** 加密<br>* 用私钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPrivateKey(byte[] data, String key)throws Exception {// 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 取得私钥** @param keyMap* @return* @throws Exception*/public static String getPrivateKey(Map<String, Key> keyMap)throws Exception {Key key = (Key) keyMap.get(PRIV ATE_KEY);return encryptBASE64(key.getEncoded());}/*** 取得公钥** @param keyMap* @return* @throws Exception*/public static String getPublicKey(Map<String, Key> keyMap)throws ption {Key key = keyMap.get(PUBLIC_KEY);return encryptBASE64(key.getEncoded());}/*** 初始化密钥** @return* @throws Exception*/public static Map<String, Key> initKey() throws Exception {KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);keyPairGen.initialize(1024);KeyPair keyPair = keyPairGen.generateKeyPair();Map<String, Key> keyMap = new HashMap(2);keyMap.put(PUBLIC_KEY, keyPair.getPublic());// 公钥keyMap.put(PRIV ATE_KEY, keyPair.getPrivate());// 私钥return keyMap;}}测试类RSACoderTest.javaimport org.junit.Before;import org.junit.Test;import java.security.Key;import java.util.Map;import static org.junit.Assert.assertEquals;import static org.junit.Assert.assertTrue;/*** Created by lake on 17-4-12.*/public class RSACoderTest {private String publicKey;private String privateKey;@Beforepublic void setUp() throws Exception {Map<String, Key> keyMap = RSACoder.initKey();publicKey = RSACoder.getPublicKey(keyMap);privateKey = RSACoder.getPrivateKey(keyMap);System.err.println("公钥: \n\r" + publicKey);System.err.println("私钥:\n\r" + privateKey);}@Testpublic void test() throws Exception {System.err.println("公钥加密——私钥解密");String inputStr = "abc";byte[] encodedData = RSACoder.encryptByPublicKey(inputStr, publicKey);byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,teKey);String outputStr = new String(decodedData);System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);assertEquals(inputStr, outputStr);}@Testpublic void testSign() throws Exception {System.err.println("私钥加密——公钥解密");String inputStr = "sign";byte[] data = inputStr.getBytes();byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);byte[] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);String outputStr = new String(decodedData);System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);assertEquals(inputStr, outputStr);System.err.println("私钥签名——公钥验证签名");// 产生签名String sign = RSACoder.sign(encodedData, privateKey);System.err.println("签名:" + sign);// 验证签名boolean status = RSACoder.verify(encodedData, publicKey, sign);System.err.println("状态:" + status);assertTrue(status);}}前端代码依赖jsencrypt 项目<script src="bin/jsencrypt.min.js"></script><script type="xt/javascript">var encrypt = new JSEncrypt();encrypt.setPublicKey('java生成的公钥');var encrypted = encrypt.encrypt('加密的字符串');</script>说明前端生成加密的字符串encrypted,传到后台,java使用私钥进行解密即可。