0
0

前端国密4（SM4）加密解密

项目使用到数据加密，选用了国密4，输出文本用了base64包装，网上也看了很多文档，但是都不行，所以自己整理了一下

引入第三方依赖

使用了js-base64依赖，需要提前安装一下，执行

  1. npm install --save js-base64

复制下方代码即可使用

  1. import { toUint8Array, fromUint8Array} from 'js-base64'
  2. const UINT8_BLOCK = 16;
  3. const Sbox = [
  4.     0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
  5.     0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
  6.     0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
  7.     0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
  8.     0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
  9.     0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
  10.     0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
  11.     0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
  12.     0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
  13.     0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
  14.     0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
  15.     0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
  16.     0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
  17.     0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
  18.     0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
  19.     0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48
  20. ];
  21. const CK = [
  22.     0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
  23.     0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
  24.     0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
  25.     0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
  26.     0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
  27.     0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
  28.     0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
  29.     0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
  30. ];
  31. const FK = [
  32.     0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc
  33. ];
  35. /**
  36.  * 将字符串转为Unicode数组
  37.  * @example "1234" => [49, 50, 51, 52];
  38.  * @param {String} str 要转换的字符串
  39.  * @returns {Number[]} 转换后的数组
  40.  */
  41. const stringToArray = (str: string) => {
  42.     if(!/string/gi.test(Object.prototype.toString.call(str))){
  43.         str = JSON.stringify(str);
  44.     }
  45.     //@ts-ignore
  46.     return encodeURIComponent(str).split("").map(val => val.charCodeAt());
  47. }
  49. const rotateLeft = (x: number, y: number) => {
  50.     return x << y | x >>> (32 - y);
  51. }
  53. const tauTransform = (a: number) => {
  54.     return Sbox[a >>> 24 & 0xff] << 24 | Sbox[a >>> 16 & 0xff] << 16 | Sbox[a >>> 8 & 0xff] << 8 | Sbox[a & 0xff];
  55. }
  57. const tTransform1 = (z: number) => {
  58.     let b = tauTransform(z);
  59.     let c = b ^ rotateLeft(b, 2) ^ rotateLeft(b, 10) ^ rotateLeft(b, 18) ^ rotateLeft(b, 24);
  60.     return c
  61. }
  63. const tTransform2 = (z: number) => {
  64.     let b = tauTransform(z);
  65.     let c = b ^ rotateLeft(b, 13) ^ rotateLeft(b, 23);
  66.     return c
  67. }
  69. const EncryptRoundKeys = (key: number[]) => {
  70.     const keys = [];
  71.     const mk = [
  72.         key[0] << 24 | key[1] << 16 | key[2] << 8 | key[3],
  73.         key[4] << 24 | key[5] << 16 | key[6] << 8 | key[7],
  74.         key[8] << 24 | key[9] << 16 | key[10] << 8 | key[11],
  75.         key[12] << 24 | key[13] << 16 | key[14] << 8 | key[15]
  76.     ];
  78.     let k = new Array(36);
  79.     k[0] = mk[0] ^ FK[0];
  80.     k[1] = mk[1] ^ FK[1];
  81.     k[2] = mk[2] ^ FK[2];
  82.     k[3] = mk[3] ^ FK[3];
  84.     for (let i = 0; i < 32; i++) {
  85.         k[i + 4] = k[i] ^ tTransform2(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i]);
  86.         keys[i] = k[i + 4];
  87.     }
  89.     return keys;
  90. }
  92. const getChainBlock = (arr: any[] | Uint8Array | null, baseIndex = 0) => {
  93.     if (arr === null) throw new Error('Block is invalid')
  94.     let block = [
  95.         arr[baseIndex] << 24 | arr[baseIndex + 1] << 16 | arr[baseIndex + 2] << 8 | arr[baseIndex + 3],
  96.         arr[baseIndex + 4] << 24 | arr[baseIndex + 5] << 16 | arr[baseIndex + 6] << 8 | arr[baseIndex + 7],
  97.         arr[baseIndex + 8] << 24 | arr[baseIndex + 9] << 16 | arr[baseIndex + 10] << 8 | arr[baseIndex + 11],
  98.         arr[baseIndex + 12] << 24 | arr[baseIndex + 13] << 16 | arr[baseIndex + 14] << 8 | arr[baseIndex + 15]
  99.     ];
  100.     return block;
  101. }
  103. const doBlockCrypt = (blockData: any[], roundKeys: any[]) => {
  104.     let xBlock = new Array(36);
  105.     blockData.forEach((val: any, index: number) => xBlock[index] = val);
  106.     // loop to process 32 rounds crypt
  107.     for (let i = 0; i < 32; i++) {
  108.         xBlock[i + 4] = xBlock[i] ^ tTransform1(xBlock[i + 1] ^ xBlock[i + 2] ^ xBlock[i + 3] ^ roundKeys[i]);
  109.     }
  110.     let yBlock = [xBlock[35], xBlock[34], xBlock[33], xBlock[32]];
  111.     return yBlock;
  112. }
  114. const padding = (originalBuffer: any[] | null) => {
  115.     if (originalBuffer === null) {
  116.         return null;
  117.     }
  118.     let paddingLength = UINT8_BLOCK - originalBuffer.length % UINT8_BLOCK;
  119.     let paddedBuffer = new Array(originalBuffer.length + paddingLength);
  120.     originalBuffer.forEach((val: any, index: number) => paddedBuffer[index] = val);
  121.     paddedBuffer.fill(paddingLength, originalBuffer.length);
  122.     return paddedBuffer;
  123. }
  125. const dePadding = (paddedBuffer: string | any[] | null) => {
  126.     if (paddedBuffer === null) {
  127.         return null;
  128.     }
  129.     let paddingLength = paddedBuffer[paddedBuffer.length - 1];
  130.     let originalBuffer = paddedBuffer.slice(0, paddedBuffer.length - paddingLength);
  131.     return originalBuffer;
  132. }
  134. const check = (name: string, str: string | any[]) => {
  135.     if(!str || str.length != 16){
  136.         console.error(`${name} should be a 16 bytes string.`);
  137.         return false;
  138.     }
  139.     return true;
  140. }
  142. /**
  143.  * CBC加密模式
  144.  * @example encryptCBC("1234", "1234567890123456", "1234567890123456") => "K++iI4IhSGMnEJZT/jv1ow=="
  145.  * @param {any} plaintext 要加密的数据
  146.  * @param {String} key
  147.  * @param {String} iv
  148.  * @param {String} mode base64 | "text"
  149.  * @returns {String} 加密后的字符串
  150.  */
  151. const encryptCBC = (plaintext: string, key: string, iv: string, mode = "base64") => {
  152.     if(!check("iv", iv) && !check("key", key)){return;}
  154.     let encryptRoundKeys = EncryptRoundKeys(stringToArray(key));
  155.     let plainByteArray = stringToArray(plaintext);
  156.     let padded = padding(plainByteArray);
  157.     if(padded == null) throw new Error('padded is invalid')
  158.     let blockTimes = padded.length / UINT8_BLOCK;
  159.     let outArray = [];
  160.     // init chain with iv (transform to uint32 block)
  161.     let chainBlock = getChainBlock(stringToArray(iv));
  162.     for (let i = 0; i < blockTimes; i++) {
  163.         // extract the 16 bytes block data for this round to encrypt
  164.         let roundIndex = i * UINT8_BLOCK;
  165.         let block = getChainBlock(padded, roundIndex);
  166.         // xor the chain block
  167.         chainBlock[0] = chainBlock[0] ^ block[0];
  168.         chainBlock[1] = chainBlock[1] ^ block[1];
  169.         chainBlock[2] = chainBlock[2] ^ block[2];
  170.         chainBlock[3] = chainBlock[3] ^ block[3];
  171.         // use chain block to crypt
  172.         let cipherBlock = doBlockCrypt(chainBlock, encryptRoundKeys);
  173.         // make the cipher block be part of next chain block
  174.         chainBlock = cipherBlock;
  175.         for (let l = 0; l < UINT8_BLOCK; l++) {
  176.             outArray[roundIndex + l] = cipherBlock[Math.floor(l / 4)] >> ((3 - l) % 4 * 8) & 0xff;
  177.         }
  178.     }
  180.     // cipher array to string
  181.     if (mode === 'base64') {
  182.         return fromUint8Array(new Uint8Array(outArray));
  183.     } else {
  184.         // text
  185.         return decodeURIComponent(String.fromCharCode(...outArray));
  186.     }
  187. }
  188. /**
  189.  * ECB加密模式
  190.  * @example encryptECB("1234", "1234567890123456") => "woPrxebr8Xvyo1qG8QxAUA=="
  191.  * @param {any} plaintext 要加密的数据
  192.  * @param {String} key
  193.  * @param {String} iv
  194.  * @param {String} mode base64 | "text"
  195.  * @returns {String} 加密后的字符串
  196.  */
  197. const encryptECB = (plaintext: string, key: string, mode = "base64") => {
  198.     // if(!check("iv", iv)){return;}
  200.     let encryptRoundKeys = EncryptRoundKeys(stringToArray(key));
  201.     let plainByteArray = stringToArray(plaintext);
  202.     let padded = padding(plainByteArray);
  203.     if(padded == null) throw new Error('padded is invalid')
  204.     let blockTimes = padded.length / UINT8_BLOCK;
  205.     let outArray = [];
  206.     // CBC mode
  207.     // init chain with iv (transform to uint32 block)
  208.     for (let i = 0; i < blockTimes; i++) {
  209.         // extract the 16 bytes block data for this round to encrypt
  210.         let roundIndex = i * UINT8_BLOCK;
  211.         let block = getChainBlock(padded, roundIndex);
  212.         let cipherBlock = doBlockCrypt(block, encryptRoundKeys);
  213.         for (let l = 0; l < UINT8_BLOCK; l++) {
  214.             outArray[roundIndex + l] = cipherBlock[Math.floor(l / 4)] >> ((3 - l) % 4 * 8) & 0xff;
  215.         }
  216.     }
  218.     // cipher array to string
  219.     if (mode === 'base64') {
  220.         return fromUint8Array(new Uint8Array(outArray));
  221.     } else {
  222.         // text
  223.         return decodeURIComponent(String.fromCharCode(...outArray));
  224.     }
  225. }
  226. /**
  227.  * CBC解密模式
  228.  * @example decryptCBC("K++iI4IhSGMnEJZT/jv1ow==", "1234567890123456", "1234567890123456") => "1234"
  229.  * @param {any} plaintext 要解密的数据
  230.  * @param {String} key
  231.  * @param {String} iv
  232.  * @param {String} mode base64 | "text"
  233.  * @returns {String} 解密后的字符串
  234.  */
  235. const decryptCBC = (ciphertext: string, key: string, iv: string, mode = "base64") => {
  236.     if(!check("iv", iv) && !check("key", key)){return;}
  237.     // get cipher byte array
  238.     let cipherByteArray = null;
  239.     let decryptRoundKeys = EncryptRoundKeys(stringToArray(key)).reverse();
  240.     if (mode === 'base64') {
  241.         // cipher is base64 string
  242.         cipherByteArray = toUint8Array(ciphertext);
  243.     } else {
  244.         // cipher is text
  245.         cipherByteArray = stringToArray(ciphertext);
  246.     }
  248.     let blockTimes = cipherByteArray.length / UINT8_BLOCK;
  249.     let outArray = [];
  251.     // init chain with iv (transform to uint32 block)
  252.     let chainBlock = getChainBlock(stringToArray(iv));
  253.     for (let i = 0; i < blockTimes; i++) {
  254.         // extract the 16 bytes block data for this round to encrypt
  255.         let roundIndex = i * UINT8_BLOCK;
  256.         // make Uint8Array to Uint32Array block
  257.         let block = getChainBlock(cipherByteArray, roundIndex);
  258.         // reverse the round keys to decrypt
  259.         let plainBlockBeforeXor = doBlockCrypt(block, decryptRoundKeys);
  260.         // xor the chain block
  261.         let plainBlock = [
  262.             chainBlock[0] ^ plainBlockBeforeXor[0],
  263.             chainBlock[1] ^ plainBlockBeforeXor[1],
  264.             chainBlock[2] ^ plainBlockBeforeXor[2],
  265.             chainBlock[3] ^ plainBlockBeforeXor[3]
  266.         ];
  267.         // make the cipher block be part of next chain block
  268.         chainBlock = block;
  269.         for (let l = 0; l < UINT8_BLOCK; l++) {
  270.             outArray[roundIndex + l] = plainBlock[Math.floor(l / 4)] >> ((3 - l) % 4 * 8) & 0xff;
  271.         }
  272.     }
  273.     // depadding the decrypted data
  274.     let depaddedPlaintext = dePadding(outArray);
  275.     // transform data to utf8 string
  276.     //@ts-ignore
  277.     return decodeURIComponent(String.fromCharCode(...depaddedPlaintext));
  278. }
  279. /**
  280.  * ECB解密模式
  281.  * @example decryptECB("woPrxebr8Xvyo1qG8QxAUA==", "1234567890123456") => "1234"
  282.  * @param {any} plaintext 要解密的数据
  283.  * @param {String} key
  284.  * @param {String} iv
  285.  * @param {String} mode base64 | "text"
  286.  * @returns {String} 解密后的字符串
  287.  */
  288. const decryptECB = (ciphertext: string, key: string, mode = "base64") => {
  289.     // if(!check("iv", iv)){return;}
  290.     // get cipher byte array
  291.     let decryptRoundKeys = EncryptRoundKeys(stringToArray(key)).reverse();
  292.     let cipherByteArray = null;
  293.     if (mode === 'base64') {
  294.         // cipher is base64 string
  295.         cipherByteArray = toUint8Array(ciphertext);
  296.     } else {
  297.         // cipher is text
  298.         cipherByteArray = stringToArray(ciphertext);
  299.     }
  300.     let blockTimes = cipherByteArray.length / UINT8_BLOCK;
  301.     let outArray = [];
  303.     for (let i = 0; i < blockTimes; i++) {
  304.         // extract the 16 bytes block data for this round to encrypt
  305.         let roundIndex = i * UINT8_BLOCK;
  306.         // make Uint8Array to Uint32Array block
  307.         let block = getChainBlock(cipherByteArray, roundIndex);
  308.         // reverse the round keys to decrypt
  309.         let plainBlock = doBlockCrypt(block, decryptRoundKeys);
  310.         for (let l = 0; l < UINT8_BLOCK; l++) {
  311.             outArray[roundIndex + l] = plainBlock[Math.floor(l / 4)] >> ((3 - l) % 4 * 8) & 0xff;
  312.         }
  313.     }
  315.     // depadding the decrypted data
  316.     let depaddedPlaintext = dePadding(outArray);
  317.     // transform data to utf8 string
  318.     //@ts-ignore
  319.     return decodeURIComponent(String.fromCharCode(...depaddedPlaintext));
  320. }
  322. export {
  323.     decryptECB,
  324.     encryptECB,
  325.     decryptCBC,
  326.     encryptCBC,
  327. }
标签： 前端 同态加密
本文转载自: https://blog.csdn.net/lichenglin123/article/details/137006063
版权归原作者 我家有位小可爱 所有， 如有侵权，请联系我们删除。
登录后发布评论

“前端国密4（SM4）加密解密”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？