jsras加密
发布时间: 2022-06-08 07:43:44
❶ 如何使用javascript进行RSA/ECB/PKCS1Padding算法加密
javascript rsa加密/java使用Cipher.getInstance("RSA/ECB/PKCS1Padding")解密
1)服务器端获得生成密钥对;
2)javascript使用公钥加密；
3)java获得密文使用私钥解密；
❷ 怎么能通过js实现rsa加密
很简单，C#自带了很多算法，DES,RSA,这些都可以自己加密解密。前面一个人说的MD5就没法解密的了，那个是标签类加密不可逆。可以自己网络我说的两个，也可以直接问我这代码怎么写。
❸ 如何实现用javascript实现rsa加解密
服务端生成公钥与私钥，保存。
客户端在请求到登录页面后，随机生成一字符串。
后此随机字符串作为密钥加密密码，再用从服务端获取到的公钥加密生成的随机字符串
将此两段密文传入服务端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。这其中有一个关键是解决服务端的公钥，传入客户端，客户端用此公钥加密字符串后，后又能在服务端用私钥解出。
步骤：
服务端的RSAJava实现：
/**
*
*/
packagecom.sunsoft.struts.util;
importjava.io.ByteArrayOutputStream;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.math.BigInteger;
importjava.security.KeyFactory;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.NoSuchAlgorithmException;
importjava.security.PrivateKey;
importjava.security.PublicKey;
importjava.security.SecureRandom;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.InvalidKeySpecException;
importjava.security.spec.RSAPrivateKeySpec;
importjava.security.spec.RSAPublicKeySpec;
importjavax.crypto.Cipher;/**
*RSA工具类。提供加密，解密，生成密钥对等方法。
*需要到
下载bcprov-jdk14-123.jar。
*
*/
publicclassRSAUtil{
/**
**生成密钥对*
*
*@returnKeyPair*
*@throwsEncryptException
*/
()throwsException{
try{
KeyPairGeneratorkeyPairGen=KeyPairGenerator.getInstance("RSA",
neworg.bouncycastle.jce.provider.BouncyCastleProvider());
finalintKEY_SIZE=1024;//没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
keyPairGen.initialize(KEY_SIZE,newSecureRandom());
KeyPairkeyPair=keyPairGen.generateKeyPair();
saveKeyPair(keyPair);
returnkeyPair;
}catch(Exceptione){
thrownewException(e.getMessage());
}
}
publicstaticKeyPairgetKeyPair()throwsException{
FileInputStreamfis=newFileInputStream("C:/RSAKey.txt");
ObjectInputStreamoos=newObjectInputStream(fis);
KeyPairkp=(KeyPair)oos.readObject();
oos.close();
fis.close();
returnkp;
}
publicstaticvoidsaveKeyPair(KeyPairkp)throwsException{
FileOutputStreamfos=newFileOutputStream("C:/RSAKey.txt");
ObjectOutputStreamoos=newObjectOutputStream(fos);
//生成密钥
oos.writeObject(kp);
oos.close();
fos.close();
}
/**
**生成公钥*
*
*@parammolus*
*@parampublicExponent*
*@returnRSAPublicKey*
*@throwsException
*/
(byte[]molus,
byte[]publicExponent)throwsException{
KeyFactorykeyFac=null;
try{
keyFac=KeyFactory.getInstance("RSA",
neworg.bouncycastle.jce.provider.BouncyCastleProvider());
}catch(NoSuchAlgorithmExceptionex){
thrownewException(ex.getMessage());
}
RSAPublicKeySpecpubKeySpec=newRSAPublicKeySpec(newBigInteger(
molus),newBigInteger(publicExponent));
try{
return(RSAPublicKey)keyFac.generatePublic(pubKeySpec);
}catch(InvalidKeySpecExceptionex){
thrownewException(ex.getMessage());
}
}
/**
**生成私钥*
*
*@parammolus*
*@paramprivateExponent*
*@returnRSAPrivateKey*
*@throwsException
*/
(byte[]molus,
byte[]privateExponent)throwsException{
KeyFactorykeyFac=null;
try{
keyFac=KeyFactory.getInstance("RSA",
neworg.bouncycastle.jce.provider.BouncyCastleProvider());
}catch(NoSuchAlgorithmExceptionex){
thrownewException(ex.getMessage());
}
RSAPrivateKeySpecpriKeySpec=newRSAPrivateKeySpec(newBigInteger(
molus),newBigInteger(privateExponent));
try{
return(RSAPrivateKey)keyFac.generatePrivate(priKeySpec);
}catch(InvalidKeySpecExceptionex){
thrownewException(ex.getMessage());
}
}
/**
**加密*
*
*@paramkey
*加密的密钥*
*@paramdata
*待加密的明文数据*
*@return加密后的数据*
*@throwsException
*/
publicstaticbyte[]encrypt(PublicKeypk,byte[]data)throwsException{
try{
Ciphercipher=Cipher.getInstance("RSA",
neworg.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE,pk);
intblockSize=cipher.getBlockSize();//获得加密块大小，如：加密前数据为128个byte，而key_size=1024
//加密块大小为127
//byte,加密后为128个byte;因此共有2个加密块，第一个127
//byte第二个为1个byte
intoutputSize=cipher.getOutputSize(data.length);//获得加密块加密后块大小
intleavedSize=data.length%blockSize;
intblocksSize=leavedSize!=0?data.length/blockSize+1
:data.length/blockSize;
byte[]raw=newbyte[outputSize*blocksSize];
inti=0;
while(data.length-i*blockSize>0){
if(data.length-i*blockSize>blockSize)
cipher.doFinal(data,i*blockSize,blockSize,raw,i
*outputSize);
else
cipher.doFinal(data,i*blockSize,data.length-i
*blockSize,raw,i*outputSize);
//这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
//ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
//OutputSize所以只好用dofinal方法。
i++;
}
returnraw;
}catch(Exceptione){
thrownewException(e.getMessage());
}
}
/**
**解密*
*
*@paramkey
*解密的密钥*
*@paramraw
*已经加密的数据*
*@return解密后的明文*
*@throwsException
*/
publicstaticbyte[]decrypt(PrivateKeypk,byte[]raw)throwsException{
try{
Ciphercipher=Cipher.getInstance("RSA",
neworg.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(cipher.DECRYPT_MODE,pk);
intblockSize=cipher.getBlockSize();
ByteArrayOutputStreambout=newByteArrayOutputStream(64);
intj=0;
while(raw.length-j*blockSize>0){
bout.write(cipher.doFinal(raw,j*blockSize,blockSize));
j++;
}
returnbout.toByteArray();
}catch(Exceptione){
thrownewException(e.getMessage());
}
}
/**
***
*
*@paramargs*
*@throwsException
*/
publicstaticvoidmain(String[]args)throwsException{
RSAPublicKeyrsap=(RSAPublicKey)RSAUtil.generateKeyPair().getPublic();
Stringtest="helloworld";
byte[]en_test=encrypt(getKeyPair().getPublic(),test.getBytes());
byte[]de_test=decrypt(getKeyPair().getPrivate(),en_test);
System.out.println(newString(de_test));
}
}测试页面IndexAction.java：
/*
*GeneratedbyMyEclipseStruts
*Templatepath:templates/java/JavaClass.vtl
*/
packagecom.sunsoft.struts.action;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importorg.apache.struts.action.Action;
importorg.apache.struts.action.ActionForm;
importorg.apache.struts.action.ActionForward;
importorg.apache.struts.action.ActionMapping;
importcom.sunsoft.struts.util.RSAUtil;
/**
*MyEclipseStruts
*Creationdate:06-28-2008
*
*XDocletdefinition:
*@struts.actionvalidate="true"
*/
{
/*
*GeneratedMethods
*/
/**
*Methodexecute
*@parammapping
*@paramform
*@paramrequest
*@paramresponse
*@returnActionForward
*/
publicActionForwardexecute(ActionMappingmapping,ActionFormform,
HttpServletRequestrequest,HttpServletResponseresponse)throwsException{
RSAPublicKeyrsap=(RSAPublicKey)RSAUtil.getKeyPair().getPublic();
Stringmole=rsap.getMolus().toString(16);
Stringempoent=rsap.getPublicExponent().toString(16);
System.out.println("mole");
System.out.println(mole);
System.out.println("empoent");
System.out.println(empoent);
request.setAttribute("m",mole);
request.setAttribute("e",empoent);
returnmapping.findForward("login");
}
}通过此action进入登录页面，并传入公钥的Molus 与PublicExponent的hex编码形式。
❹ 如何在 js 里 RSA 加密然后再python 里解密
所说所有的变量都是对象。 对象在python里，其实是一个指针，指向一个数据结构，数据结构里有属性，有方法。
对象通常就是指变量。从面向对象OO的概念来讲，对象是类的一个实例。在python里很简单，对象就是变量。
class A:
myname="class a"
上面就是一个类。不是对象
a=A()
这里变量a就是一个对象。
它有一个属性（类属性），myname，你可以显示出来
print a.myname
所以，你看到一个变量后面跟点一个小数点。那么小数点后面
❺ js rsa加密可以破解吗
要看ras秘钥长度，现在普遍2048bit，要通过公钥暴力计算私钥目前还不现实。
❻ 用JavaScript实现RSA加密和解密
下面是一个我收藏的函数，用于计算rsa的pow和mod有很高的效率。我不知道是什么算法，但这个函数真的很好用。
function RSAPowMod(txt, key, n) {
var a, b;
if (key % 2 == 0) {
a = 1
for (var i = 1; i <= key / 2; i++) {
b = (txt * txt) % n
a = (b * a) % n
}
} else {
a = txt
for (var i = 1; i <= key / 2; i++) {
b = (txt * txt) % n
a = (b * a) % n
}
}
return a;
}
txt，key，n都可以是字符串，代表着大数，当然，具体大到什么范围我不知道。
大于65535的数我测试过，表示支持不止两字节了，那推测是四字节或者以上。
当我用九位数和十位数的时候，计算效率就不行。中间的，比如七位八位数的，我没有现成的密钥对，测试不了。
把对应的变量名改一改就符合要求了。（其实不用改，直接使用函数也是可以的。）
热点内容