【转】js 原生 aes rsa 加解密 及 CryptoJS 加解密

最新推荐文章于 2024-09-26 16:40:33 发布
最新推荐文章于 2024-09-26 16:40:33 发布
阅读量1.8k 收藏
点赞数
分类专栏： 加解密 文章标签： 加解密 js html5 ViewUI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anole2012/article/details/84903891
版权
本文介绍了如何使用JavaScript原生API和CryptoJS库进行AES和RSA加解密操作。示例代码包括了创建密钥对、加密解密过程，以及在不同环境下的加解密实现，如浏览器端和Java端。
摘要由CSDN通过智能技术生成

 

http://www.oschina.net/code/snippet_552425_46178

 

<!doctype html>

<html>

    <head>

        <meta charset='UTF-8'>

    </head>

    <body>

        <div class='test'></div>

        <script type="text/javascript">

 

            function encrypt(data, keyJSON){

                var data = new TextEncoder("UTF-8").encode(data);

                var randomsKeys = geneRandomHexStr(64); // 128 bit keys

                var encryptedKey = hexStringToUint8Array(randomsKeys);

                var aesAlgo = {name: 'aes-cbc', iv: hexStringToUint8Array("000102030405060708090a0b0c0d0e0f")};

                return crypto.subtle.importKey("jwk", keyJSON, {name: "rsa-oaep", hash: {name: "sha-256"}},true, ['encrypt'])

                    .then(function(publicKey){

                        return crypto.subtle.encrypt({name: "rsa-oaep"}, publicKey, encryptedKey);

                    }).then(function(res){

                        encryptedKey = bytesToHexString(res)

                        // use aes to encrypt data

                        // import aes key

                        return crypto.subtle.importKey('raw', 

                            hexStringToUint8Array(randomsKeys) , aesAlgo, false, ['encrypt', 'decrypt']);

                         

                    }).then(function(result){

                        // use aes to encode

                        return crypto.subtle.encrypt(aesAlgo,

                         result, data);

                    }).then(function(encryptedData){

                        return Promise.resolve({

                            'encrypted': bytesToHexString(encryptedData),

                            'encryptedKey': encryptedKey,

                        });

                    });

 

                //console.log(new TextDecoder("UTF-8").decode(data));

                // use server public key to encrypt

                 

            }

 

            function decrypt(data, keyJSON){

                // use local private key to decrypt

                var encryptedKey = new hexStringToUint8Array(data.encryptedKey);

                var encryptedData = new hexStringToUint8Array(data.encrypted);

                var aesAlgo = {name: 'aes-cbc', iv: hexStringToUint8Array("000102030405060708090a0b0c0d0e0f")};

                // decrypt key

                return crypto.subtle.importKey('jwk', keyJSON, {name: "rsa-oaep", hash: {name: "sha-256"}}, true,

                    ['decrypt']).then(function(privateKey){

                        return crypto.subtle.decrypt({name: 'rsa-oaep'}, privateKey, encryptedKey);

                    }).then(function(decryptedKey){

                        // import aes key

                        return crypto.subtle.importKey('raw', 

                            decryptedKey, aesAlgo, false, ['encrypt', 'decrypt']);

                    }).catch(function(){

                        console.error("decrypt error");

                    }).then(function(result){

                        // decode encrypted data

                        return crypto.subtle.decrypt(aesAlgo, result, encryptedData);

                    }).then(function(data){

                        return Promise.resolve(new TextDecoder("UTF-8").decode(new Uint8Array(data)));

                    })

 

            }

 

            function createNewUserKey(){

                var algorithmKeyGen = {

                    name: "RSA-OAEP",

                    hash: {name: "sha-256"},

                    // RsaKeyGenParams

                    modulusLength: 2048,

                    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

                };

                var nonExtractable = false;

                 

                var publicKey = "";

                var privateKey = "";

                var keyPairs = "";

                return crypto.subtle.generateKey(algorithmKeyGen, true, ['encrypt', 'decrypt']).then(function(result) {

                    // gene key pair

                    keyPairs = result;

                    return Promise.all([crypto.subtle.exportKey("jwk", keyPairs.publicKey),

                        crypto.subtle.exportKey("jwk", keyPairs.privateKey)]);

                })

                 

            }

 

            function _arrayBufferToBase64( buffer ) {

                var binary = '';

                var bytes = new Uint8Array( buffer );

                var len = bytes.byteLength;

                for (var i = 0; i < len; i++) {

                    binary += String.fromCharCode( bytes[ i ] );

                }

                return window.btoa( binary );

            }

 

            function hexStringToUint8Array(hexString) {

                if (hexString.length % 2 != 0)

                    throw "Invalid hexString";

                var arrayBuffer = new Uint8Array(hexString.length / 2);

                for (var i = 0; i < hexString.length; i += 2) {

                    var byteValue = parseInt(hexString.substr(i, 2), 16);

                    if (byteValue == NaN)

                        throw "Invalid hexString";

                    arrayBuffer[i/2] = byteValue;

                }

                return arrayBuffer;

            }

 

            function bytesToHexString(bytes) {

                if (!bytes)

                    return null;

                bytes = new Uint8Array(bytes);

                var hexBytes = [];

                for (var i = 0; i < bytes.length; ++i) {

                    var byteString = bytes[i].toString(16);

                    if (byteString.length < 2)

                        byteString = "0" + byteString;

                    hexBytes.push(byteString);

                }

                return hexBytes.join("");

            }

 

            function geneRandomHexStr(length){

                var text = "";

                var possible = "0123456789abcdef";

 

                for( var i=0; i < length; i++ )

                    text += possible.charAt(Math.floor(Math.random() * possible.length));

 

                return text;

            }

 

            createNewUserKey().then(function(keyPairs){

                encrypt("this is origin text", keyPairs[0]).then(function(res){

                    console.log('public', JSON.stringify(keyPairs[0]));

                    console.log('private', JSON.stringify(keyPairs[1]));

                    decrypt(res, keyPairs[1]).then(function(decrypted){

                        console.log('decrypted', decrypted);

                    });

                });

            })

 

        </script>

    </body>

</html>

 

---------------------------------------------------------------------------------------------------------------------------

<!DOCTYPE html>

<html>

<head>

<meta http-equiv=Content-Type content="text/html;charset=utf-8">

<meta charset="=utf-8"/>

<script type="text/javascript" src = 'crypto-js.js'></script>

<script type="text/javascript">

var key = CryptoJS.enc.Utf8.parse('1234567890123456');

var iv  = CryptoJS.enc.Utf8.parse('1234567890123456');

console.log("key::"+key.toString(CryptoJS.enc.Hex));

console.log("iv::"+iv.toString(CryptoJS.enc.Hex));

var value = '你好呀你好嘛你好吗你好哦';

var encryptData = CryptoJS.AES.encrypt(CryptoJS.enc.Utf8.parse(value), key, {

mode: CryptoJS.mode.CBC,

padding: CryptoJS.pad.Pkcs7,

iv:iv

});

var encryptDataHex = encryptData.ciphertext.toString(CryptoJS.enc.Hex);

console.log(encryptDataHex);

var base64 = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Hex.parse(encryptDataHex));

var bytes  = CryptoJS.AES.decrypt(base64, key, {

mode: CryptoJS.mode.CBC,

padding: CryptoJS.pad.Pkcs7,

iv:iv

});

console.log("encryptedData = %s", bytes.toString(CryptoJS.enc.Utf8));

</script>

</head>

<body>

</body>

</html>

 

-------------------------------------------------------------------------------------------------

对应java代码

-------------------------------------------------------------------------------------------------

 

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package com.icss.regie.crypto;

 

import java.security.Key;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.Security;

import java.util.Arrays;

import javax.crypto.Cipher;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

 

/**

 *

 * @author Administrator

 */

/**

 *

 * @author ngh

 * AES128 算法

 *

 * CBC 模式

 *

 * PKCS7Padding 填充模式

 *

 * CBC模式需要添加一个参数iv

 *

 * 介于java 不支持PKCS7Padding，只支持PKCS5Padding 但是PKCS7Padding 和 PKCS5Padding 没有什么区别

 * 要实现在java端用PKCS7Padding填充，需要用到bouncycastle组件来实现

 */

public class AES {

 // 算法名称

 final String KEY_ALGORITHM = "AES";

 // 加解密算法/模式/填充方式

 final String algorithmStr = "AES/CBC/PKCS7Padding";

 //

 private Key key;

 private Cipher cipher;

 boolean isInited = false;

 

 public void init(byte[] keyBytes) {

 

  // 如果密钥不足16位，那么就补足.  这个if 中的内容很重要

  int base = 16;

  if (keyBytes.length % base != 0) {

   int groups = keyBytes.length / base + (keyBytes.length % base != 0 ? 1 : 0);

   byte[] temp = new byte[groups * base];

   Arrays.fill(temp, (byte) 0);

   System.arraycopy(keyBytes, 0, temp, 0, keyBytes.length);

   keyBytes = temp;

  }

  // 初始化

  Security.addProvider(new BouncyCastleProvider());

  // 转化成JAVA的密钥格式

  key = new SecretKeySpec(keyBytes, KEY_ALGORITHM);

  try {

   // 初始化cipher

   cipher = Cipher.getInstance(algorithmStr, "BC");

  } catch (NoSuchAlgorithmException e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  } catch (NoSuchPaddingException e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  } catch (NoSuchProviderException e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  }

 }

 /**

  * 加密方法

  *

  * @param content

  *            要加密的字符串

  * @param keyBytes

  *            加密密钥

  * @return

  */

 public byte[] encrypt(byte[] content, byte[] keyBytes,String ivParameter) {

  byte[] encryptedText = null;

  init(keyBytes);

  System.out.println("IV：" + ivParameter);

  try {

   cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(ivParameter.getBytes("utf-8")));

   encryptedText = cipher.doFinal(content);

  } catch (Exception e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  }

  return encryptedText;

 }

 /**

  * 解密方法

  *

  * @param encryptedData

  *            要解密的字符串

  * @param keyBytes

  *            解密密钥

  * @return

  */

 public byte[] decrypt(byte[] encryptedData, byte[] keyBytes,String ivParameter) {

  byte[] encryptedText = null;

  init(keyBytes);

  System.out.println("IV：" + ivParameter);

  try {

   cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(ivParameter.getBytes("utf-8")));

   encryptedText = cipher.doFinal(encryptedData);

  } catch (Exception e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  }

  return encryptedText;

 }

}

 

 

------------------------------

 

public class Test {

 

    public static void main(String[] args) throws UnsupportedEncodingException {

        AES aes = new AES();

                

        String sKey="1234567890123456";

        

        String ivParameter="1234567890123456";

        // 需要加密的字串

        String cSrc = "你好呀你好嘛你好吗你好哦";

        

        System.out.println("key:::"+ Test.bytesToHexString(sKey.getBytes("UTF-8")));

        System.out.println("ivParameter:::"+Test.bytesToHexString(ivParameter.getBytes("UTF-8")));

        System.out.println("加密前的字串是："+cSrc);

        // 加密

        byte[] result = aes.encrypt(cSrc.getBytes("UTF-8"),sKey.getBytes("UTF-8"),ivParameter);

        

        System.out.println("加密后的字串是："+ Test.bytesToHexString(result));

        System.out.println("238f93338d84edb47c544aca7f09ae25e6b867f2befbf38dbe3a95bfa487e212c915b90a7ccbb5fd0c7970ba7a975bc1".equals(Test.bytesToHexString(result)));

        // 解密

        byte[] DeString = aes.decrypt(result,sKey.getBytes("UTF-8"),ivParameter);

        System.out.println("解密后的字串是：" + Test.bytesToHexString(DeString));

        System.out.println("e4bda0e5a5bde59180e4bda0e5a5bde5989be4bda0e5a5bde59097e4bda0e5a5bde593a6".equals(Test.bytesToHexString(DeString)));

        System.out.println("解密后的字串是：" + new String(DeString,Charset.forName("UTF-8")));

    }

 

    public static String bytesToHexString(byte[] src) {

        StringBuilder stringBuilder = new StringBuilder("");

        if (src == null || src.length <= 0) {

            return null;

        }

        for (int i = 0; i < src.length; i++) {

            int v = src[i] & 0xFF;

            String hv = Integer.toHexString(v);

            if (hv.length() < 2) {

                stringBuilder.append(0);

            }

            stringBuilder.append(hv);

        }

        return stringBuilder.toString();

    }

 

    /**

     * Convert hex string to byte[]

     *

     * @param hexString the hex string

     * @return byte[]

     */

    public static byte[] hexStringToBytes(String hexString) {

        if (hexString == null || hexString.equals("")) {

            return null;

        }

        hexString = hexString.toUpperCase();

        int length = hexString.length() / 2;

        char[] hexChars = hexString.toCharArray();

        byte[] d = new byte[length];

        for (int i = 0; i < length; i++) {

            int pos = i * 2;

            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));

        }

        return d;

    }

 

    /**

     * Convert char to byte

     *

     * @param c char

     * @return byte

     */

    private static byte charToByte(char c) {

        return (byte) "0123456789ABCDEF".indexOf(c);

    }

}

anole2012
关注
专栏目录
html使用aes进行加密
ddtzlbxr38191的博客
07-12 2054
1.导入 aes.js 文件 　　 !function(t,n){"object"==typeof exports?module.exports=exports=n():"function"==typeof define&&define.amd?define([],n):t.CryptoJS=n()}(this,function(){var t=t||functi...
原生js的RSA和AES加密解密算法
11-26
本文实例为大家分享了js中RSA和AES加密解密详细代码，供大家参考，具体内容如下 <!doctype html> <html> <head> <meta charset='UTF-8'> </head> <body> [removed] function encrypt(data, keyJSON){ var data = new TextEncoder("UTF-8").encode(data); var randomsKeys = geneRandomH
js java aes rsa_原生js的RSA和AES加密解密详解
weixin_39543773的博客
02-26 267
function encrypt(data, keyJSON){var data = new TextEncoder("UTF-8").encode(data);var randomsKeys = geneRandomHexStr(64); // 128 bit keysvar encryptedKey = hexStringToUint8Array(randomsKeys);var aesAlg...
JavaScript页面加密实用技术：Base64、MD5和SHA案例解析
最新发布
weixin_30820933的博客
09-26 1387
本文还有配套的精品资源，点击获取 简介：JavaScript是网页开发的关键脚本语言，常用于处理客户端逻辑和服务器通信。为确保代码安全，开发者会采用加密技术对JavaScript页面进行加密。本文重点介绍了三种常用加密方法：Base64编码、MD5和SHA哈希算法，并提供了实现这些加密方法的简单代码示例。Base64适用于数据传输，MD5和SHA则主要用于数据校验和密码存储...
原生JS的加密解密
mab_1994的博客
01-16 742
<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> <script> var s="abc121321dsadsa"; console.log(window.btoa(s));//YWJjMTIxMzIxZHNhZHNh con
cryptoJs加密解密工具
07-20
cryptoJs加密解密工具，并集成EncryptAes、DecryptAes两个方法，require(util.js)即可用。参数以json方式传递
RSA加密解密 PHP JS
04-27
在JavaScript中，由于原生支持相对较弱，通常会借助如`crypto-js`或`node-rsa`这样的库来实现RSA加密。对于前端应用，通常我们会使用公钥加密敏感数据，然后在服务器端用私钥解密。例如，`crypto-js`库提供了一个...
Javascript 加密解密 CryptoJS
08-02
JavaScript加密解密库CryptoJS是开发人员在Web应用中实现安全数据处理的常用工具，尤其在需要保护用户敏感信息如密码、API密钥等场景下。这个库支持多种加密算法，包括对称加密（如AES、DES）、非对称加密（如RSA）...
java与javascript互相加解密
04-07
本篇将深入探讨如何使用DES（Data Encryption Standard）算法在Java和JavaScript之间进行安全的加解密操作。 DES是一种对称加密算法，它使用相同的密钥进行加密和解密，具有速度快、效率高的特点，但因为其密钥长度...
CryptoJS 完整源码
07-19
CryptoJS 是一个开源的JavaScript库，专为加密和解密数据而设计。它提供了一系列强大的加密算法，包括AES（高级加密标准）、DES（数据加密标准）、RSA（公钥加密算法）等。这个库广泛用于浏览器端的加密需求，特别是...
RSA和AES工具.zip
01-26
在Web前端，由于浏览器的安全策略，直接使用原生JavaScript进行RSA和AES加密可能受到限制。通常，RSA的公钥可以安全地暴露给前端用于加密，而后端服务器会使用私钥解密。对于AES，可以使用Web Crypto API进行加密，...
CryptoJS文件-提供各种加密解密算
03-31
CryptoJS提供各种加密解密算法， 并且里面有个aes的简单实现，希望可以帮助大家
hybrid-crypto-js：针对JavaScript的RSA + AES混合加密实现。 与Node.js，React Native和现代浏览器一起使用
02-06
混合加密JS 介绍 混合加密JS是用于JavaScript的混合（RSA + AES）加密和解密工具包。 Hybrid Crypto JS结合了RSA和AES加密算法，可以有效地加密和解密大型邮件。 该跨平台库基于 。 Hybrid Crypto JS可以在浏览器，Node.js或React Native中使用。 文献资料 入门 产品特点 安装 npm install hybrid-crypto-js 输入 Node.js var RSA = require ( 'hybrid-crypto-js' ) . RSA ; var Crypt = require ( 'hybrid-crypto
前后端加密CryptoJS包
06-13
前后端分离时会遇到一些数据传输安全问题，这时候大家就考虑到前后端能互通加密解密，前端就使用这个包可以搞定
cryptojs完整代码
03-17
cryptojs 是一个js 加密的类库　
js使用aes加密
白白的博客
09-13 1904
var key = CryptoJS.enc.Utf8.parse(“你的key”); //加密 function encrypt(word) { var srcs = CryptoJS.enc.Utf8.parse(word); var encrypt = CryptoJS.AES.encrypt(srcs,key,{ mode:CryptoJS.mode.ECB, padding:CryptoJS.pad.Pkcs7 }); return encrypt.toString(); } .
JS AES加密解密实现
qq_43351249的博客
07-07 2244
aes加密解密问题
js实现AES加密解密，简易又全面
weixin_42050406的博客
12-05 4126
常规是直接安装CryptoJS库，但为了减少项目体积，使用这简单的20k文件就ok。代码中使用的是Pkcs7，但我需要的填充方式是ZeroPadding。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值