js参数rsa加密长度限制_Rsa 算法加密的数据块大小问题

㈠后台加密后的密码，js如何限制页面上的密码长度

如果你说的是多玩游戏里面的盒子的话。就是下载完之后好像就有一个使用图标。或者你可以从我的资源那里找到你下载的插件，开启就好了，记住必须在多玩盒子里启动游戏，插件才有用。

㈡ RSA加密算法最多支持多少位，最少多少位，较合理的又是多少位，求解

最少几位都可以，最多几位都可以，根据安全性，现在通用的是512以上，1024位和2048位比较安全。少了比较容易破解掉，多了计算非常慢

㈢ Rsa 算法加密的数据块大小问题

PQ的积M叫做模，模规定了这个数字空间中最大的数，是这个空间的边界，这个空间中所有的数都要小于模M，包括被加密的消息块。所以如果消息（a1,a2,a3...）任何一个超过了M，加密后都无法正切解密，因为加密后和解密后得到的数都在这个空间中，不可能得到一个大于M的数。

但是如果用来加密的消息A大于M，解密后得到的结果加上K倍的M一定会等于A，因为加密的过程是做模乘操作，大于M的消息A首先被除M然后取余数了，该余数一定小于M，然后所有的加密操作都是针对该余数来进行的，想要还原A的话用该A模M的余数加上数倍的M就可以了。解密的话还原的也是该余数，得到余数后还原A,也是加上数倍的M就可以了。

实质上RSA的加密有个条件，消息A必须要小于M。

㈣ DES、RSA的明文长度和密文长度分别是多少

加密的明文长度不能超过RSA密钥的长度-11，比如1024位的，明文长度不能超过117。密文的长度总是密钥的长度的一半，比如1024位的，密文长度是64，如果是1032位，密文长度是65位。

㈤前台js实现的RSA加密，用C#模拟登陆，实现的加密算法，密文长度不一样

很简单，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编码形式。

㈦ rsa加密数据太长怎么办

RSA是一种块文件加密系统，他需要将输入的数据分成固定大小的块，然后对这些数据块进行加密。加密以后输出的数据块长度和输入时一样的。你发现加密后的长度不同的话，应该是RSA加密的那个padding（填充）配置不一样，从而使得每次加密数据块的长度不同，这样最后出来的长度也就不一样了。

㈧用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的数我测试过，表示支持不止两字节了，那推测是四字节或者以上。
当我用九位数和十位数的时候，计算效率就不行。中间的，比如七位八位数的，我没有现成的密钥对，测试不了。
把对应的变量名改一改就符合要求了。（其实不用改，直接使用函数也是可以的。）

导航:首页 > 文档加密 > js参数rsa加密长度限制

js参数rsa加密长度限制

与js参数rsa加密长度限制相关的资料