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加密長度限制相關的資料