golang、JS AES(CBC模式)加密解密兼容

golang代码

package crypto

import (

	"bytes"

	"crypto/aes"

	"crypto/cipher"

	"encoding/hex"

	"errors"

	"fmt"

)

//参考文档

//http://www.topgoer.com/%E5%85%B6%E4%BB%96/%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86/%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86.html

//高级加密标准（Adevanced Encryption Standard ,AES）

//16,24,32位字符串的话，分别对应AES-128，AES-192，AES-256 加密方法

//key不能泄露

//var PwdKey = []byte("DIS**#KKKDJJSKDI")

var PwdKey = "linkbook1qaz*WSX"

//PKCS7 填充模式

func PKCS7Padding(ciphertext []byte, blockSize int) []byte {

	padding := blockSize - len(ciphertext)%blockSize

	//Repeat()函数的功能是把切片[]byte{byte(padding)}复制padding个，然后合并成新的字节切片返回

	padtext := bytes.Repeat([]byte{byte(padding)}, padding)

	return append(ciphertext, padtext...)

}

//填充的反向操作，删除填充字符串

func PKCS7UnPadding1(origData []byte) ([]byte, error) {

	//获取数据长度

	length := len(origData)

	if length == 0 {

		return nil, errors.New("加密字符串错误！")

	} else {

		//获取填充字符串长度

		unpadding := int(origData[length-1])

		//截取切片，删除填充字节，并且返回明文

		return origData[:(length - unpadding)], nil

	}

}

//实现加密

func AesEcrypt(origData []byte, key []byte) ([]byte, error) {

	//创建加密算法实例

	block, err := aes.NewCipher(key)

	if err != nil {

		return nil, err

	}

	//获取块的大小

	blockSize := block.BlockSize()

	//对数据进行填充，让数据长度满足需求

	origData = PKCS7Padding(origData, blockSize)

	//采用AES加密方法中CBC加密模式

	blocMode := cipher.NewCBCEncrypter(block, key[:blockSize])

	crypted := make([]byte, len(origData))

	//执行加密

	blocMode.CryptBlocks(crypted, origData)

	return crypted, nil

}

//实现解密

func AesDeCrypt(cypted []byte, key []byte) (string, error) {

	//创建加密算法实例

	block, err := aes.NewCipher(key)

	if err != nil {

		return "", err

	}

	//获取块大小

	blockSize := block.BlockSize()

	//创建加密客户端实例

	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])

	origData := make([]byte, len(cypted))

	//这个函数也可以用来解密

	blockMode.CryptBlocks(origData, cypted)

	//去除填充字符串

	origData, err = PKCS7UnPadding1(origData)

	if err != nil {

		return "", err

	}

	return string(origData), err

}

//加密base64

func EnPwdCode(pwdStr string) string {

	pwd := []byte(pwdStr)

	result, err := AesEcrypt(pwd, []byte(PwdKey))

	if err != nil {

		return ""

	}

	return hex.EncodeToString(result)

}

//解密

func DePwdCode(pwd string) string {

	temp, _ := hex.DecodeString(pwd)

	//执行AES解密

	res, _:=AesDeCrypt(temp, []byte(PwdKey))

	return res

}

func main() {

	//aes加密

	destring:=`{"name":"菜鸟教程11","site":"http://www.runoob.com"}`

	deStr := EnPwdCode(destring)

	fmt.Println(deStr) //4f4d74c15e0ad4afb323a17927b1176ecb0c95ecbdf8e776ceb093499e3ff4c45157b007ae7dff1688ac2d2bf9fef28644922a1b3bbc6ef5881cb1ed0dff298a

	//aes解密

	decodeStr := DePwdCode("4f4d74c15e0ad4afb323a17927b1176ecb0c95ecbdf8e776ceb093499e3ff4c45157b007ae7dff1688ac2d2bf9fef28644922a1b3bbc6ef5881cb1ed0dff298a")

	fmt.Println(decodeStr) //{"name":"菜鸟教程11","site":"http://www.runoob.com"}

}

前端javascript的代码

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <title>Title</title>

</head>

<script src="./aes.js"></script>

<body>

  <script>

    // var key1 = "1234567887654321";

    var key1 = "linkbook1qaz*WSX";

    // var plaintText = '"name"="lisi",age=18'; // 明文

    var str = {

      name: "菜鸟教程11",

      site: "http://www.runoob.com"

    }

    var plaintText = JSON.stringify(str)

    console.log(plaintText)

    endata = encodeAes(plaintText)

    //加密

    function encodeAes(plaintTextStr) {

      var key = CryptoJS.enc.Utf8.parse(key1);

      var encryptedData = CryptoJS.AES.encrypt(plaintText, key, {

        iv: key,

        mode: CryptoJS.mode.CBC,

        padding: CryptoJS.pad.Pkcs7

      });

      // console.log("加密前：" + plaintText);

      // console.log("加密后：" + encryptedData);    //Pkcs7:   WoCzvm6eZiM4/bx5o/CzGw==

      // console.log("加密后 base64：" + encryptedData.ciphertext.toString(CryptoJS.enc.Base64));

      encryptedData = encryptedData.ciphertext.toString();

      console.log("加密后-no-hex：" + encryptedData);

      return encryptedData

    }

    // 解密

    endata1 = "46ce4f5bb33896c4c75a24a46c6f16c32991228f40831003b98acffe41fee255f892d68283b8a1b07a4dfd66622b6c50685854e918ac059d5d8e969b3b105c6b";

    decodeAes(endata1)

    function decodeAes(encryptedDataStr) {

      var key = CryptoJS.enc.Utf8.parse(key1);

      var encryptedHexStr = CryptoJS.enc.Hex.parse(encryptedDataStr);

      // console.log("解密前hex：" + encryptedHexStr);

      var encryptedBase64Str = CryptoJS.enc.Base64.stringify(encryptedHexStr);

      // console.log("解密前：" + encryptedBase64Str);

      var decryptedData = CryptoJS.AES.decrypt(encryptedBase64Str, key, {

        iv: key,

        mode: CryptoJS.mode.CBC,

        padding: CryptoJS.pad.Pkcs7

      });

      var decryptedStr = decryptedData.toString(CryptoJS.enc.Utf8);

      console.log("解密后:" + decryptedStr);

    }

  </script>

</body>

</html>

aes.js

github下载地址：

https://github.com/brix/crypto-js/blob/develop/src/aes.js

(function () {

    // Shortcuts

    var C = CryptoJS;

    var C_lib = C.lib;

    var BlockCipher = C_lib.BlockCipher;

    var C_algo = C.algo;

    // Lookup tables

    var SBOX = [];

    var INV_SBOX = [];

    var SUB_MIX_0 = [];

    var SUB_MIX_1 = [];

    var SUB_MIX_2 = [];

    var SUB_MIX_3 = [];

    var INV_SUB_MIX_0 = [];

    var INV_SUB_MIX_1 = [];

    var INV_SUB_MIX_2 = [];

    var INV_SUB_MIX_3 = [];

    // Compute lookup tables

    (function () {

        // Compute double table

        var d = [];

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

            if (i < 128) {

                d[i] = i << 1;

            } else {

                d[i] = (i << 1) ^ 0x11b;

            }

        }

        // Walk GF(2^8)

        var x = 0;

        var xi = 0;

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

            // Compute sbox

            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);

            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;

            SBOX[x] = sx;

            INV_SBOX[sx] = x;

            // Compute multiplication

            var x2 = d[x];

            var x4 = d[x2];

            var x8 = d[x4];

            // Compute sub bytes, mix columns tables

            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);

            SUB_MIX_0[x] = (t << 24) | (t >>> 8);

            SUB_MIX_1[x] = (t << 16) | (t >>> 16);

            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);

            SUB_MIX_3[x] = t;

            // Compute inv sub bytes, inv mix columns tables

            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);

            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);

            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);

            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);

            INV_SUB_MIX_3[sx] = t;

            // Compute next counter

            if (!x) {

                x = xi = 1;

            } else {

                x = x2 ^ d[d[d[x8 ^ x2]]];

                xi ^= d[d[xi]];

            }

        }

    }());

    // Precomputed Rcon lookup

    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];

    /**

     * AES block cipher algorithm.

     */

    var AES = C_algo.AES = BlockCipher.extend({

        _doReset: function () {

            var t;

            // Skip reset of nRounds has been set before and key did not change

            if (this._nRounds && this._keyPriorReset === this._key) {

                return;

            }

            // Shortcuts

            var key = this._keyPriorReset = this._key;

            var keyWords = key.words;

            var keySize = key.sigBytes / 4;

            // Compute number of rounds

            var nRounds = this._nRounds = keySize + 6;

            // Compute number of key schedule rows

            var ksRows = (nRounds + 1) * 4;

            // Compute key schedule

            var keySchedule = this._keySchedule = [];

            for (var ksRow = 0; ksRow < ksRows; ksRow++) {

                if (ksRow < keySize) {

                    keySchedule[ksRow] = keyWords[ksRow];

                } else {

                    t = keySchedule[ksRow - 1];

                    if (!(ksRow % keySize)) {

                        // Rot word

                        t = (t << 8) | (t >>> 24);

                        // Sub word

                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];

                        // Mix Rcon

                        t ^= RCON[(ksRow / keySize) | 0] << 24;

                    } else if (keySize > 6 && ksRow % keySize == 4) {

                        // Sub word

                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];

                    }

                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;

                }

            }

            // Compute inv key schedule

            var invKeySchedule = this._invKeySchedule = [];

            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {

                var ksRow = ksRows - invKsRow;

                if (invKsRow % 4) {

                    var t = keySchedule[ksRow];

                } else {

                    var t = keySchedule[ksRow - 4];

                }

                if (invKsRow < 4 || ksRow <= 4) {

                    invKeySchedule[invKsRow] = t;

                } else {

                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^

                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];

                }

            }

        },

        encryptBlock: function (M, offset) {

            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);

        },

        decryptBlock: function (M, offset) {

            // Swap 2nd and 4th rows

            var t = M[offset + 1];

            M[offset + 1] = M[offset + 3];

            M[offset + 3] = t;

            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);

            // Inv swap 2nd and 4th rows

            var t = M[offset + 1];

            M[offset + 1] = M[offset + 3];

            M[offset + 3] = t;

        },

        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {

            // Shortcut

            var nRounds = this._nRounds;

            // Get input, add round key

            var s0 = M[offset]     ^ keySchedule[0];

            var s1 = M[offset + 1] ^ keySchedule[1];

            var s2 = M[offset + 2] ^ keySchedule[2];

            var s3 = M[offset + 3] ^ keySchedule[3];

            // Key schedule row counter

            var ksRow = 4;

            // Rounds

            for (var round = 1; round < nRounds; round++) {

                // Shift rows, sub bytes, mix columns, add round key

                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];

                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];

                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];

                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];

                // Update state

                s0 = t0;

                s1 = t1;

                s2 = t2;

                s3 = t3;

            }

            // Shift rows, sub bytes, add round key

            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];

            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];

            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];

            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];

            // Set output

            M[offset]     = t0;

            M[offset + 1] = t1;

            M[offset + 2] = t2;

            M[offset + 3] = t3;

        },

        keySize: 256/32

    });

    /**

     * Shortcut functions to the cipher's object interface.

     *

     * @example

     *

     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);

     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);

     */

    C.AES = BlockCipher._createHelper(AES);

}());

golang、JS AES(CBC模式)加密解密兼容的更多相关文章

Android DES加密的CBC模式加密解密和ECB模式加密解密
DES加密共有四种模式:电子密码本模式(ECB).加密分组链接模式(CBC).加密反馈模式(CFB)和输出反馈模式(OFB). CBC模式加密: import java.security.Key; i ...
通过Jni实现AES的CBC模式加密解密
AES加密方式基本实现,出现一个问题就是代码的安全性.我们知道java层代码很容易被反编译,很有可能泄漏我们加密方式与密钥内容,那我们该怎么办呢?我们可以使用c/c++实现加密,编译成So库的形式, ...
php实现AES/CBC/PKCS5Padding加密解密（又叫：对称加密）
今天在做一个和java程序接口的架接,java那边需要我这边(PHP)对传过去的值进行AES对称加密,接口返回的结果也是加密过的(就要用到解密),然后试了很多办法,也一一对应了AES的key密钥值,偏 ...
python 实现 AES CBC模式加解密
AES加密方式有五种:ECB, CBC, CTR, CFB, OFB 从安全性角度推荐CBC加密方法,本文介绍了CBC,ECB两种加密方法的python实现 python 在 Windows下使用AE ...
解决AES算法CBC模式加密字符串后再解密出现乱码问题
问题在使用 AES CBC 模式加密字符串后,再进行解密,解密得到的字符串出现乱码情况,通常都是前几十个字节乱码: 复现因为是使用部门 cgi AESEncryptUtil 库,找到问题后,在这里 ...
php AES cbc模式 pkcs7 128位加密解密(微信小程序)
PHP AES CBC模式PKCS7 128位加密加密: $key = '1234567812345678'; $iv = '1234567890123456'; $message = '12345 ...
PHP AES cbc模式 pkcs7 128加密解密
今天在对接一个第三方接口的时候,对方需要AES CBC模式下的加密.这里简单写一个demo class Model_Junjingbao extends Model { private static ...
Python实现AES的CBC模式加密和解密过程详解和 chr() 函数和 s[a:b:c] 和函数lambda
1.chr()函数 chr() 用一个范围在 range(256)内的(就是0-255)整数作参数,返回一个对应的字符. 2.s[a:b:c] s=(1,2,3,4,5) 1>. s[a]下标访 ...
golang AES/ECB/PKCS5 加密解密 url-safe-base64
因为项目的需要用到golang的一种特殊的加密解密算法AES/ECB/PKCS5,但是算法并没有包含在标准库中,经过多次失败的尝试,终于解码成功,特此分享: /* 描述 : golang AES/EC ...
微信小程序aes前后端加密解密交互
aes前后端加密解密交互小程序端 1. 首先引入aes.js /** * [description] CryptoJS v3.1.2 * [description] zhuangzhudada so ...

随机推荐

表名大小写混合时格式问题及sys_dump导出时的注意事项
前言前几天碰到同事咨询一个有关sys_dump导出时,表名为大小写混合情况的报错问题.因为sys_dump命令运行在linux操作系统上,所以这涉及到linux中shell的语法格式问题. 下面模拟 ...
archlinux 安装后xfce没有声音，声音无法调节
参照 http://ivo-wang.github.io/2018/02/17/fix/ sudo pacman -S alsa-utils pavucontrol sudo pacman -S pi ...
Spark的基本原理
Application Application是在使用spark-submit 提交的打包程序,也就是需要写的代码.完整的Application一般包含以下步骤:(1)获取数据(2)计算逻辑(3)输出 ...
#cdq分治，树状数组#洛谷 4169 [Violet]天使玩偶/SJY摆棋子
题目分析首先如果不会$\text{K-DTree}$的话,那就用CDQ分治吧这题首先要去绝对值,分四种情况讨论, 只判断左下角的点然后考虑怎样求最大值,这里采用树状数组,反正只是单点修改单 ...
#SG函数#HDU 1848 Fibonacci again and again
题目分析可取状态只能是斐波那契数,求出SG函数然后判断三个数sg函数异或和不为0先手必胜代码 #include <cstdio> #include <cctype> # ...
如何知道 window 的 load 事件已经触发
背景为了使页面加载更快,常常将一些不重要的第三方脚本在页面完成加载后进行懒加载. // 做一些不影响业务的事情 window.addEventListener('load', () => { ...
CentOS上搭建FTP服务器[未测试]
centos ftp服务器 linux service upload 防火墙本文参考了网上的几篇博文,在CentOS上搭建FTP服务器,两种搭建方式:gssftp与vsftpd. RedHat和Ce ...
mysql 必知必会整理—全球化与本地化[十六]
前言简单介绍一下字符集. 数据库表被用来存储和检索数据.不同的语言和字符集需要以不同的方式存储和检索. 因此,MySQL需要适应不同的字符集(不同的字母和字符),适应不同的排序和检索数据的方法. 字 ...
xxx，一个神奇的 Python 库
前几天,我在<技术周刊的转变:如何平衡热爱与现实?>一文里写过国内 Python 自媒体圈在近几年的两个现象(仅个人观感,无科学数据支撑): Python 广告投放出现断崖式萎缩 Pyth ...
【Oracle】PL/SQL制作唯一标识，固定字段+日期+流水码，流水码每日重置
[Oracle]PL/SQL制作唯一标识,固定字段+日期+流水码,流水码每日重置首先创建序列 create sequence sequence_name minvalue 0 maxvalue 99 ...

golang、JS AES(CBC模式)加密解密兼容

golang、JS AES(CBC模式)加密解密兼容

golang代码

前端javascript的代码

aes.js

golang、JS AES(CBC模式)加密解密兼容的更多相关文章

随机推荐

热门专题