js文件加密解密的方式

㈠ 关于JS加密,这个是什么加密方式如何进行加密和解密

7种加密方式：http://www.codesky.net/article/200911/165731.html

㈡ 如何破解JS脚本加密

在网页中加入一个，然后在加密代码中找document.write()，eval()，execScript()或VBS的EXECUTE语句，并用document.getElementById("textareaID").innerText=STR 替换。加密就不攻自破了。www.hrbfc120.com
(STR是转换好的字符串变量，如在加密代码中找到 document.write(s); 就用 document.getElementById("textareaID").innerText=s; 替换)

㈢ 用jQuery.md5.js加密密码后后台怎么解密

MD5不是加密算法，它是Hash算法，所以它不可逆，也没法还原成原文。
你可以用base64、异或或者aes des等加密算法去实现。

㈣ 前端js 加密解密方式

一、base64加密
使用JS函数的window.btoa()和 window.atob()，分别是中腊编码和解码

二、编码和解码字符串

使用JS函巧羡数卖宽滑的escape()和unescape()，分别是编码和解码

三、AES加密解密
四、RSA加密解密

㈤ 如何实现用javascript实现rsa加解密

用javascript实现rsa加解密的实现方式是通过PKCS完成的。
1、整个定义的function

function pkcs1pad2(s,n) {
if(n < s.length + 11) { // TODO: fix for utf-8
alert("Message too long for RSA");
return null;
}
var ba = new Array();
var i = s.length - 1;
while(i >= 0 && n > 0) {
var c = s.charCodeAt(i--);
//UTF-8编码为变长字节,使用实际的字节来记录
if(c < 128) { // encode using utf-8
ba[--n] = c;
}
else if((c > 127) && (c < 2048)) {
ba[--n] = (c & 63) | 128;
ba[--n] = (c >> 6) | 192;
}
else {
ba[--n] = (c & 63) | 128;
ba[--n] = ((c >> 6) & 63) | 128;
ba[--n] = (c >> 12) | 224;
}
}
//实际输入拼装结束,将下一位赋值为0标记结束
ba[--n] = 0;
var rng = new SecureRandom();
var x = new Array();
//拼接随机非0字节
while(n > 2) { // random non-zero pad
x[0] = 0;
while(x[0] == 0) rng.nextBytes(x);
ba[--n] = x[0];
}
//这两位做简单的校验
ba[--n] = 2;
ba[--n] = 0;
return new BigInteger(ba);
}
该方法中对UTF-8字符进行了兼容，并且在拼装完实际输入的字符后，还拼装了随机的字节，使用拼装后的字符串去加密。由于每次拼装的结果是随机的，这样每次加密后的密文都不同。
2、调用方法：；
function RSAEncrypt(text) {
var m = pkcs1pad2(text,(this.n.bitLength()+7)>>3);
if(m == null) return null;
var c = this.doPublic(m);
if(c == null) return null;
var h = c.toString(16);
if((h.length & 1) == 0) return h; else return "0" + h;
}

㈥ js中常见的数据加密与解密的方法

加密在我们前端的开发中也是经常遇见的。本文只把我们常用的加密方法进行总结。不去纠结加密的具体实现方式（密码学，太庞大了）。

常见的加密算法基本分为这几类，

RSA加密：RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。（这才是正经的加密算法）

非对称加密算法：非对称加密算法需要两个密钥：公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法

DES算法的入口参数有三个：Key、Data、Mode。其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种:加密或解密。

AES这个标准用来替代原先的DES

DES/AES我们合并在一起介绍其用法和特点

Base64是一种用64个字符来表示任意二进制数据的方法。base64是一种编码方式而不是加密算法。只是看上去像是加密而已（吓唬人）。

㈦ 如何实现用javascript实现rsa加解密

1. 服务端生成公钥与私钥，保存。

2. 客户端在请求到登录页面后，随机生成一字符串。

3. 后此随机字符串作为密钥加密密码，再用从服务端获取到的公钥加密生成的随机字符串

4. 将此两段密文传入服务端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。这其中有一个关键是解决服务端的公钥，传入客户端，客户端用此公钥加密字符串后，后又能在服务端用私钥解出。

步骤：

1. 服务端的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));
   }
   }

2. 测试页面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编码形式。