搭建测试环境、完成弘则研报h5页

.gitignore

@@ -1 +1,3 @@
 node_modules
+dist
+rarwechat_link_h5

config/dev.env.js

@@ -4,4 +4,9 @@ module.exports = {
 	API_ROOT:'"/api"',  //开发环境
 	Domain:'"brilliantstart.cn"',
   linkurl:'"http://wechat.brilliantstart.cn:2346"',
+
+  	ROUTER_BASE:"'/'",
+
+	FICC_API_ROOT:"'http://8.136.199.33:8612'",//弘则研报地址开发地址
+
 };

config/index.js

@@ -10,7 +10,7 @@ module.exports = {
 
     // Paths
     assetsSubDirectory: 'static',
-    assetsPublicPath: '/',
+    assetsPublicPath: process.env.ROUTER_BASE,
     proxyTable:{
     	'/api': {
     		target:'http://8.136.199.33:8500', // 接口的域名
@@ -65,7 +65,7 @@ module.exports = {
     // Paths
     assetsRoot: path.resolve(__dirname, '../raiwechat_link_h5'),
     assetsSubDirectory: 'static',
-    assetsPublicPath: './',
+    assetsPublicPath: process.env.ROUTER_BASE,
     // productionSourceMap: true,
     // Gzip off by default as many popular static hosts such as
     // Surge or Netlify already gzip all static assets for you.
@@ -95,7 +95,7 @@ module.exports = {
     // Paths
     assetsRoot: path.resolve(__dirname, '../dist'),
     assetsSubDirectory: 'static',
-    assetsPublicPath: './',
+    assetsPublicPath: process.env.ROUTER_BASE,
     productionSourceMap: true,
     // Gzip off by default as many popular static hosts such as
     // Surge or Netlify already gzip all static assets for you.

config/prod.env.js

@@ -4,4 +4,8 @@ module.exports = {
   API_ROOT:'"https://cygx.hzinsights.com/api"',  //生产环境
   Domain:'"hzinsights.com"',
   linkurl:'"https://share.hzinsights.com"',
+
+  ROUTER_BASE:"'/'",
+  
+  FICC_API_ROOT:"'http://8.136.199.33:8612'",//弘则研报地址生产环境
 };

config/prod.test.env.js

@@ -5,4 +5,7 @@ module.exports = {
   API_ROOT:'"http://8.136.199.33:8500/api"',  //测试环境
   Domain:'"brilliantstart.cn"',
   linkurl:'"http://share.brilliantstart.cn"',
+
+  ROUTER_BASE:"'/xcx_h5'",
+  FICC_API_ROOT:"'http://8.136.199.33:8612'",//弘则研报地址测试环境
 };

src/api/ficc_yb/api.js

@@ -0,0 +1,6 @@
+import {get,post} from './http'
+
+// 获取报告详情
+export const apiReportDetail=params=>{
+    return get('/report/research_report',params)
+}

src/api/ficc_yb/http.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import Vue from "vue";
+import axios from "axios";
+import { Toast } from "vant";
+// Full config:  https://github.com/axios/axios#request-config
+// axios.defaults.baseURL = process.env.baseURL || process.env.apiUrl || '';
+// axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
+// axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+
+// 请求数
+let LOADINGCOUNT = 0;
+let LOADING;
+
+let config = {
+  baseURL: process.env.FICC_API_ROOT,
+  timeout: 60 * 1000 // Timeout
+  // withCredentials: true, // Check cross-site Access-Control
+};
+
+const _axios = axios.create(config);
+
+_axios.interceptors.request.use(
+  function(config) {
+    // Do something before request is sent
+
+    // 设置loading
+    if (LOADINGCOUNT === 0) {
+      LOADING = Toast.loading({
+        message: "loading...",
+        duration: 0,
+        forbidClick: true
+      });
+    }
+    LOADINGCOUNT++;
+
+    return config;
+  },
+  function(error) {
+    // Do something with request error
+    return Promise.reject(error);
+  }
+);
+
+// Add a response interceptor
+_axios.interceptors.response.use(
+  function(response) {
+    // Do something with response data
+
+    //关闭loading
+    LOADINGCOUNT--;
+    if (LOADINGCOUNT == 0) {
+      LOADING.clear();
+    }
+
+    return response.data;
+  },
+  function(error) {
+    // Do something with response error
+    return Promise.reject(error);
+  }
+);
+
+export const get=(url,params)=>{
+    return _axios.get(url,{params})
+}
+
+export const post=(url,params)=>{
+    return _axios.post(url,params)
+}

src/router/index.js

@@ -10,6 +10,6 @@ export default new Router({
     history:true, //是否开启html5模式，去掉锚点
     saveScrollPosition:false, //记住页面的滚动位置 html5模式适用
     mode:'history',
-    base:__dirname, //这个很重要
+    base:process.env.ROUTER_BASE, //这个很重要
     routes
 });

src/router/router.js

@@ -9,7 +9,7 @@ const routes = [
     path: '/raiReportDtl',
     name: 'raiReportDtl',
     component: () => import('@/view/rai_pj/raiReportDtl.vue')
-  }
+  },
   // { path: '/noaccess', name: 'noaccess', component: () => import('@/view/noaccess.vue') },
   // { path: '/inputinfo', name: 'inputinfo', component: () => import('@/view/inputinfo.vue') },
   // { path: '/resultdis', name: 'resultdis', component: () => import('@/view/resultdis.vue') },
@@ -24,5 +24,10 @@ const routes = [
   //   name:'视频搜索',
   //   component: () => import('@/view/videoSearch.vue')
   // }
+  // 弘则研报小程序 详情
+  {
+    path:"/ficcReportDetail",
+    component:()=> import('@/view/ficc_yb/reportDetail.vue')
+  }
 ];
 export default routes;

src/view/ficc_yb/reportDetail.vue

@@ -0,0 +1,190 @@
+<template>
+  <div class="report-detail" v-if="info">
+      <div class="top-wrap" :style="'backgroundImage:url('+topBgUrl+')'">
+          <h1 class="title">{{info.research_report_info.reportVariety}}</h1>
+          <h3 class="sub-title">{{info.research_report_info.researchReportName.substring(info.research_report_info.researchReportName.indexOf('】')+1)}}</h3>
+          <div class="time-box">
+				<div class="time-num">{{subval(info.research_report_info.researchReportDate,8,10)}}</div>
+                <div>
+                    <div>{{getWeek(info.research_report_info.researchReportDate)}}</div>
+				    <div>{{subval(info.research_report_info.researchReportDate,0,7)}}</div>
+                </div>
+			</div>
+            <div class="num">第{{info.research_report_info.periods}}期</div>
+      </div>
+      <div class="content-wrap">
+          <div v-for="item in info.ResearchReportTypeContentList" :key="item.sort">
+              <h2 style="font-size:16px;margin:5px 0">{{item.content_type?item.content_type:'核心观点'}}</h2>
+              <div v-html="item.content"></div>
+          </div>
+      </div>
+      <div class="footer-wrap">
+          <img class="img" src="@/assets/img/ficc_yb/mzsm.png" alt="">
+          <div class="content">
+            <p>1、本报告仅供弘则弥道（上海）投资咨询有限公司正式签约的机构客户使用，不会仅因接收人/接受机构收到本报告而将其视为客户。</p>
+			<p>2、本报告根据国际和行业通行的准则，以合法渠道获得这些信息，尽可能保证可靠、准确和完整，但并不保证报告所述信息的准确性和完整性，也不保证本报告所包含的信息或建议在本报告发出后不会发生任何变更。本报告中所提供的信息仅供参考。</p>
+			<p>3、报告中的内容不对投资者做出的最终操作建议做任何的担保，也没有任何形式的分享投资收益或者分担投资损失的书面或口头承诺。不作为客户在投资、法律、会计或税务等方面的最终操作建议，也不作为道义的、责任的和法律的依据或者凭证，无论是否已经明示或者暗示。</p>
+			<p>4、在任何情况下，本公司不对客户/接受人/接受机构因使用报告中内容所引致的一切损失负责任，客户/接受人/接受机构需自行承担全部风险。</p>
+          </div>
+      </div>
+  </div>
+</template>
+
+<script>
+// import CryptoJS from './utils/crypto'
+import {apiReportDetail} from '@/api/ficc_yb/api.js'
+export default {
+    computed: {
+        topBgUrl(){
+            if(this.info){
+                if( this.info.research_report_info.type=='day' ){
+                    return require('@/assets/img/ficc_yb/daybanner.jpg');
+                }else if( this.info.research_report_info.type=='week' ){
+                    return require('@/assets/img/ficc_yb/weekbanner.jpg');
+                }else if( this.info.research_report_info.type=='two_week' ){
+                    return require('@/assets/img/ficc_yb/twoweekbanner.jpg');
+                }else if( this.info.research_report_info.type=='month' ){
+                    return require('@/assets/img/ficc_yb/monthbanner.jpg');
+                }else if( this.info.research_report_info.type=='other' ){
+                    return require('@/assets/img/ficc_yb/otherbanner.jpg');
+                }else{
+                    return require('@/assets/img/ficc_yb/daybanner.jpg');
+                }
+            }
+            
+        }        
+    },
+    data () {
+        return {
+            info:null 
+        }
+    },
+    created(){
+        // let str='wB7f0x+1Ar4='
+        // let res=CryptoJS.Des3Decrypt(str);
+        // console.log(res);
+        this.getDetail()
+    },
+    mounted () {
+        $(document).on('click', '.content-wrap img',function(event) {
+			let imgArray = [];
+			let curImageSrc = $(this).attr('src');
+			let oParent = $(this).parent();
+			if (curImageSrc && !oParent.attr('href')) {
+                $('.content-wrap img').each(function(index, el) {
+                    let itemSrc = $(this).attr('src');
+                    imgArray.push(itemSrc);
+                });
+                wx.previewImage({current:curImageSrc,urls:imgArray});
+			}
+		});  
+    },
+    updated () {
+      $('.content-wrap').find('img').css({display:'block',width:'100%',margin:'0 auto'});  
+    },
+    methods: {
+        subval(val,l,r){  //时间格式处理
+			return val.substring(l,r);
+		},
+        getWeek(dateString){  //日期星期转换
+			let date;
+			if( dateString == null || typeof dateString == "undefined" ){
+				date = new Date();
+			}else{
+				let dateArray = dateString.split("-");
+				date = new Date(dateArray[0], parseInt(dateArray[1] - 1), dateArray[2]);
+			}
+			return "周" + "日一二三四五六".charAt(date.getDay());
+		},
+        async getDetail(){
+            const res=await apiReportDetail({
+                Authorization:this.$route.query.token,
+                research_report_id:this.$route.query.id
+            })
+            if(res.code===200){
+                this.info=res.data
+            }
+        }
+    }
+}
+</script>
+
+<style lang="scss" scoped>
+.top-wrap{
+    width: 100%;
+    height: 200px;
+    background-size: cover;
+    background-repeat: no-repeat;
+    color: #fff;
+    padding-top: 20px;
+    position: relative;
+    h1,h3{
+        margin: 0;
+        padding: 0;
+    }
+    .title,.sub-title{
+        text-align: center;
+        width: 80%;
+        margin-left: auto;
+        margin-right: auto;
+        font-size: 26px;
+    }
+    .sub-title{
+        font-size: 18px;
+        margin-top: 40px;
+    }
+    .time-box{
+        display: flex;
+        position: absolute;
+        left: 20px;
+        bottom: 30px;
+        font-size: 12px;
+        .time-num{
+            font-size: 22px;
+            font-weight: bold;
+            border-right: 1px solid #fff;
+            margin-right: 5px;
+            padding-right: 3px;
+            line-height: 40px;
+        }
+    }
+    .num{
+        position: absolute;
+        bottom: 30px;
+        right: 20px;
+        font-size: 14px;
+    }
+}
+.footer-wrap{
+    background-color: rgb(236, 235, 235);
+    padding: 20px 16px;
+    .img{
+        display: block;
+        margin: auto;
+        height: 16px;
+        margin-bottom: 10px;
+    }
+    p{
+        margin-top: 0;
+        margin-bottom: 15px;
+    }
+    .content{
+        background-color: #fff;
+        padding: 15px;
+        border-radius: 4px;
+        line-height: 1.7;
+        color: rgb(102, 102, 102);
+    }
+}
+.content-wrap{
+    background-color: #fff;
+    margin-top: -20px;
+    border-top-left-radius: 10px;
+    border-top-right-radius: 10px;
+    min-height: 200px;
+    position: relative;
+    padding: 20px 16px;
+    font-size: 14px;
+    line-height: 1.7;
+}
+</style>

src/view/ficc_yb/utils/crypto.js

@@ -0,0 +1,787 @@
+const key = 'zDeESsxsXuionhqSLZYHWcDJ';
+
+class CryptoJS {
+	// 3DES加密，CBC/PKCS5Padding
+	static Des3Encrypt (input) {
+		let genKey = genkey(key, 0, 24);
+		return base64encode(des(genKey.key, input, 1, 1, key.substr(0, 8), 1));
+	}
+
+	// 3DES解密，CBC/PKCS5Padding
+	static Des3Decrypt (input) {
+		let genKey = genkey(key, 0, 24);
+		return des(genKey.key, base64decode(input), 0, 1, key.substr(0, 8), 1);
+	}
+
+	// md5
+	static Md5Encrypt (input) {
+		return md5(String(input));
+	}
+}
+
+function des (key, message, encrypt, mode, iv, padding) {
+	if (encrypt) // 如果是加密的话，首先转换编码
+	{ message = unescape(encodeURIComponent(message)); }
+	// declaring this locally speeds things up a bit
+	let spfunction1 = new Array(0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404, 0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000, 0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404, 0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404, 0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004);
+	let spfunction2 = new Array(-0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20, -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000, -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020, -0x7fff7fe0, 0, -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000, 0x8020, -0x7fef8000, -0x7ff00000, 0x8020, 0, 0x108020, -0x7fefffe0, 0x100000, -0x7fff7fe0, -0x7ff00000, -0x7fef8000, 0x8000, -0x7ff00000, -0x7fff8000, 0x20, -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000, -0x7fffffe0, 0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000, 0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0, 0x108000);
+	let spfunction3 = new Array(0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200, 0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208, 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208, 0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200);
+	let spfunction4 = new Array(0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001, 0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1, 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080, 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081, 0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080);
+	let spfunction5 = new Array(0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000, 0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100, 0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000, 0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100, 0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100, 0x40000100);
+	let spfunction6 = new Array(0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10, 0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10, 0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000, 0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010);
+	let spfunction7 = new Array(0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802, 0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000, 0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002);
+	let spfunction8 = new Array(0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040, 0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000);
+
+	// create the 16 or 48 subkeys we will need
+	let keys = des_createKeys(key);
+
+	let m = 0, i, j, temp, temp2, right1, right2, left, right, looping;
+	let cbcleft, cbcleft2, cbcright, cbcright2;
+	let endloop, loopinc;
+	var len = message.length;
+	let chunk = 0;
+	// set up the loops for single and triple des
+	let iterations = keys.length === 32 ? 3 : 9; // single or triple des
+	if (iterations === 3) { looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2); } else { looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2); }
+
+	// pad the message depending on the padding parameter
+	if (padding === 2) message += '        '; // pad the message with spaces
+	else if (padding === 1) {
+		if (encrypt) {
+			temp = 8 - (len % 8);
+			message += String.fromCharCode(temp, temp, temp, temp, temp, temp, temp, temp);
+			if (temp === 8) len += 8;
+		}
+	} // PKCS7 padding
+	else if (!padding) message += '\0\0\0\0\0\0\0\0'; // pad the message out with null bytes
+
+	// store the result here
+	let result = '';
+	let tempresult = '';
+
+	if (mode === 1) { // CBC mode
+		cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
+		cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
+		m = 0;
+	}
+
+	// loop through each 64 bit chunk of the message
+	while (m < len) {
+		left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+		right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+
+		// for Cipher Block Chaining mode, xor the message with the previous result
+		if (mode === 1) {
+			if (encrypt) {
+				left ^= cbcleft;
+				right ^= cbcright;
+			} else {
+				cbcleft2 = cbcleft;
+				cbcright2 = cbcright;
+				cbcleft = left;
+				cbcright = right;
+			}
+		}
+
+		// first each 64 but chunk of the message must be permuted according to IP
+		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+		right ^= temp;
+		left ^= (temp << 4);
+		temp = ((left >>> 16) ^ right) & 0x0000ffff;
+		right ^= temp;
+		left ^= (temp << 16);
+		temp = ((right >>> 2) ^ left) & 0x33333333;
+		left ^= temp;
+		right ^= (temp << 2);
+		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+		left ^= temp;
+		right ^= (temp << 8);
+		temp = ((left >>> 1) ^ right) & 0x55555555;
+		right ^= temp;
+		left ^= (temp << 1);
+
+		left = ((left << 1) | (left >>> 31));
+		right = ((right << 1) | (right >>> 31));
+
+		// do this either 1 or 3 times for each chunk of the message
+		for (j = 0; j < iterations; j += 3) {
+			endloop = looping[j + 1];
+			loopinc = looping[j + 2];
+			// now go through and perform the encryption or decryption
+			for (i = looping[j]; i !== endloop; i += loopinc) { // for efficiency
+				right1 = right ^ keys[i];
+				right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
+				// the result is attained by passing these bytes through the S selection functions
+				temp = left;
+				left = right;
+				right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] | spfunction4[(right1 >>> 16) & 0x3f] |
+					spfunction6[(right1 >>> 8) & 0x3f] | spfunction8[right1 & 0x3f] |
+					spfunction1[(right2 >>> 24) & 0x3f] | spfunction3[(right2 >>> 16) & 0x3f] |
+					spfunction5[(right2 >>> 8) & 0x3f] | spfunction7[right2 & 0x3f]);
+			}
+			temp = left;
+			left = right;
+			right = temp; // unreverse left and right
+		} // for either 1 or 3 iterations
+
+		// move then each one bit to the right
+		left = ((left >>> 1) | (left << 31));
+		right = ((right >>> 1) | (right << 31));
+
+		// now perform IP-1, which is IP in the opposite direction
+		temp = ((left >>> 1) ^ right) & 0x55555555;
+		right ^= temp;
+		left ^= (temp << 1);
+		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+		left ^= temp;
+		right ^= (temp << 8);
+		temp = ((right >>> 2) ^ left) & 0x33333333;
+		left ^= temp;
+		right ^= (temp << 2);
+		temp = ((left >>> 16) ^ right) & 0x0000ffff;
+		right ^= temp;
+		left ^= (temp << 16);
+		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+		right ^= temp;
+		left ^= (temp << 4);
+
+		// for Cipher Block Chaining mode, xor the message with the previous result
+		if (mode === 1) {
+			if (encrypt) {
+				cbcleft = left;
+				cbcright = right;
+			} else {
+				left ^= cbcleft2;
+				right ^= cbcright2;
+			}
+		}
+		tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff), ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24), ((right >>> 16) & 0xff), ((right >>> 8) & 0xff), (right & 0xff));
+
+		chunk += 8;
+		if (chunk === 512) {
+			result += tempresult;
+			tempresult = '';
+			chunk = 0;
+		}
+	} // for every 8 characters, or 64 bits in the message
+
+	// return the result as an array
+	result += tempresult;
+	result = result.replace(/\0*$/g, '');
+
+	if (!encrypt) { // 如果是解密的话，解密结束后对PKCS7 padding进行解码，并转换成utf-8编码
+		if (padding === 1) { // PKCS7 padding解码
+			var len = result.length, paddingChars = 0;
+			len && (paddingChars = result.charCodeAt(len - 1));
+			(paddingChars <= 8) && (result = result.substring(0, len - paddingChars));
+		}
+		// 转换成UTF-8编码
+		result = decodeURIComponent(escape(result));
+	}
+
+	return result;
+} // end of des
+
+// des_createKeys
+// this takes as input a 64 bit key (even though only 56 bits are used)
+// as an array of 2 integers, and returns 16 48 bit keys
+function des_createKeys (key) {
+	// declaring this locally speeds things up a bit
+	let pc2bytes0 = new Array(0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204);
+	let pc2bytes1 = new Array(0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101);
+	let pc2bytes2 = new Array(0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808);
+	let pc2bytes3 = new Array(0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000);
+	let pc2bytes4 = new Array(0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010);
+	let pc2bytes5 = new Array(0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420);
+	let pc2bytes6 = new Array(0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002);
+	let pc2bytes7 = new Array(0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800);
+	let pc2bytes8 = new Array(0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002);
+	let pc2bytes9 = new Array(0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408);
+	let pc2bytes10 = new Array(0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020);
+	let pc2bytes11 = new Array(0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200);
+	let pc2bytes12 = new Array(0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010);
+	let pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105);
+
+	// how many iterations (1 for des, 3 for triple des)
+	let iterations = key.length > 8 ? 3 : 1; // changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys
+	// stores the return keys
+	let keys = new Array(32 * iterations);
+	// now define the left shifts which need to be done
+	let shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
+	// other variables
+	let lefttemp, righttemp, m = 0, n = 0, temp;
+
+	for (let j = 0; j < iterations; j++) { // either 1 or 3 iterations
+		let left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+		let right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+
+		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+		right ^= temp;
+		left ^= (temp << 4);
+		temp = ((right >>> -16) ^ left) & 0x0000ffff;
+		left ^= temp;
+		right ^= (temp << -16);
+		temp = ((left >>> 2) ^ right) & 0x33333333;
+		right ^= temp;
+		left ^= (temp << 2);
+		temp = ((right >>> -16) ^ left) & 0x0000ffff;
+		left ^= temp;
+		right ^= (temp << -16);
+		temp = ((left >>> 1) ^ right) & 0x55555555;
+		right ^= temp;
+		left ^= (temp << 1);
+		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+		left ^= temp;
+		right ^= (temp << 8);
+		temp = ((left >>> 1) ^ right) & 0x55555555;
+		right ^= temp;
+		left ^= (temp << 1);
+
+		// the right side needs to be shifted and to get the last four bits of the left side
+		temp = (left << 8) | ((right >>> 20) & 0x000000f0);
+		// left needs to be put upside down
+		left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
+		right = temp;
+
+		// now go through and perform these shifts on the left and right keys
+		for (let i = 0; i < shifts.length; i++) {
+			// shift the keys either one or two bits to the left
+			if (shifts[i]) {
+				left = (left << 2) | (left >>> 26);
+				right = (right << 2) | (right >>> 26);
+			} else {
+				left = (left << 1) | (left >>> 27);
+				right = (right << 1) | (right >>> 27);
+			}
+			left &= -0xf;
+			right &= -0xf;
+
+			// now apply PC-2, in such a way that E is easier when encrypting or decrypting
+			// this conversion will look like PC-2 except only the last 6 bits of each byte are used
+			// rather than 48 consecutive bits and the order of lines will be according to
+			// how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
+			lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf] |
+				pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf] |
+				pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf] |
+				pc2bytes6[(left >>> 4) & 0xf];
+			righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf] |
+				pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf] |
+				pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf] |
+				pc2bytes13[(right >>> 4) & 0xf];
+			temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
+			keys[n++] = lefttemp ^ temp;
+			keys[n++] = righttemp ^ (temp << 16);
+		}
+	} // for each iterations
+	// return the keys we've created
+	return keys;
+} // end of des_createKeys
+function genkey (key, start, end) {
+	// 8 byte / 64 bit Key (DES) or 192 bit Key
+	return { key: pad(key.slice(start, end)), vector: 1 };
+}
+function pad (key) {
+	for (let i = key.length; i < 24; i++) {
+		key += '0';
+	}
+	return key;
+}
+
+let BASE64_MAPPING = [
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '+', '/'
+];
+
+/**
+ *ascii convert to binary
+ */
+let _toBinary = function (ascii) {
+	let binary = new Array();
+	while (ascii > 0) {
+		let b = ascii % 2;
+		ascii = Math.floor(ascii / 2);
+		binary.push(b);
+	}
+	/*
+	 var len = binary.length;
+	 if(6-len > 0){
+	 for(var i = 6-len ; i > 0 ; --i){
+	 binary.push(0);
+	 }
+	 } */
+	binary.reverse();
+	return binary;
+};
+
+/**
+ *binary convert to decimal
+ */
+let _toDecimal = function (binary) {
+	let dec = 0;
+	let p = 0;
+	for (let i = binary.length - 1; i >= 0; --i) {
+		let b = binary[i];
+		if (b === 1) {
+			dec += Math.pow(2, p);
+		}
+		++p;
+	}
+	return dec;
+};
+
+/**
+ *unicode convert to utf-8
+ */
+let _toUTF8Binary = function (c, binaryArray) {
+	let mustLen = (8 - (c + 1)) + ((c - 1) * 6);
+	let fatLen = binaryArray.length;
+	let diff = mustLen - fatLen;
+	while (--diff >= 0) {
+		binaryArray.unshift(0);
+	}
+	let binary = [];
+	let _c = c;
+	while (--_c >= 0) {
+		binary.push(1);
+	}
+	binary.push(0);
+	let i = 0, len = 8 - (c + 1);
+	for (; i < len; ++i) {
+		binary.push(binaryArray[i]);
+	}
+
+	for (let j = 0; j < c - 1; ++j) {
+		binary.push(1);
+		binary.push(0);
+		let sum = 6;
+		while (--sum >= 0) {
+			binary.push(binaryArray[i++]);
+		}
+	}
+	return binary;
+};
+
+let BASE64 = {
+	/**
+	 *BASE64 Encode
+	 */
+	encoder: function (str) {
+		let base64_Index = [];
+		let binaryArray = [];
+		for (var i = 0, len = str.length; i < len; ++i) {
+			let unicode = str.charCodeAt(i);
+			let _tmpBinary = _toBinary(unicode);
+			if (unicode < 0x80) {
+				let _tmpdiff = 8 - _tmpBinary.length;
+				while (--_tmpdiff >= 0) {
+					_tmpBinary.unshift(0);
+				}
+				binaryArray = binaryArray.concat(_tmpBinary);
+			} else if (unicode >= 0x80 && unicode <= 0x7FF) {
+				binaryArray = binaryArray.concat(_toUTF8Binary(2, _tmpBinary));
+			} else if (unicode >= 0x800 && unicode <= 0xFFFF) { // UTF-8 3byte
+				binaryArray = binaryArray.concat(_toUTF8Binary(3, _tmpBinary));
+			} else if (unicode >= 0x10000 && unicode <= 0x1FFFFF) { // UTF-8 4byte
+				binaryArray = binaryArray.concat(_toUTF8Binary(4, _tmpBinary));
+			} else if (unicode >= 0x200000 && unicode <= 0x3FFFFFF) { // UTF-8 5byte
+				binaryArray = binaryArray.concat(_toUTF8Binary(5, _tmpBinary));
+			} else if (unicode >= 4000000 && unicode <= 0x7FFFFFFF) { // UTF-8 6byte
+				binaryArray = binaryArray.concat(_toUTF8Binary(6, _tmpBinary));
+			}
+		}
+
+		let extra_Zero_Count = 0;
+		for (var i = 0, len = binaryArray.length; i < len; i += 6) {
+			let diff = (i + 6) - len;
+			if (diff === 2) {
+				extra_Zero_Count = 2;
+			} else if (diff === 4) {
+				extra_Zero_Count = 4;
+			}
+			// if(extra_Zero_Count > 0){
+			//  len += extra_Zero_Count+1;
+			// }
+			let _tmpExtra_Zero_Count = extra_Zero_Count;
+			while (--_tmpExtra_Zero_Count >= 0) {
+				binaryArray.push(0);
+			}
+			base64_Index.push(_toDecimal(binaryArray.slice(i, i + 6)));
+		}
+
+		let base64 = '';
+		for (var i = 0, len = base64_Index.length; i < len; ++i) {
+			base64 += BASE64_MAPPING[base64_Index[i]];
+		}
+
+		for (var i = 0, len = extra_Zero_Count / 2; i < len; ++i) {
+			base64 += '=';
+		}
+		return base64;
+	},
+	/**
+	 *BASE64  Decode for UTF-8
+	 */
+	decoder: function (_base64Str) {
+		let _len = _base64Str.length;
+		let extra_Zero_Count = 0;
+		/**
+		 *计算在进行BASE64编码的时候，补了几个0
+		 */
+		if (_base64Str.charAt(_len - 1) === '=') {
+			// alert(_base64Str.charAt(_len-1));
+			// alert(_base64Str.charAt(_len-2));
+			if (_base64Str.charAt(_len - 2) === '=') { // 两个等号说明补了4个0
+				extra_Zero_Count = 4;
+				_base64Str = _base64Str.substring(0, _len - 2);
+			} else { // 一个等号说明补了2个0
+				extra_Zero_Count = 2;
+				_base64Str = _base64Str.substring(0, _len - 1);
+			}
+		}
+
+		let binaryArray = [];
+		for (var i = 0, len = _base64Str.length; i < len; ++i) {
+			let c = _base64Str.charAt(i);
+			for (let j = 0, size = BASE64_MAPPING.length; j < size; ++j) {
+				if (c === BASE64_MAPPING[j]) {
+					let _tmp = _toBinary(j);
+					/* 不足6位的补0 */
+					let _tmpLen = _tmp.length;
+					if (6 - _tmpLen > 0) {
+						for (let k = 6 - _tmpLen; k > 0; --k) {
+							_tmp.unshift(0);
+						}
+					}
+					binaryArray = binaryArray.concat(_tmp);
+					break;
+				}
+			}
+		}
+
+		if (extra_Zero_Count > 0) {
+			binaryArray = binaryArray.slice(0, binaryArray.length - extra_Zero_Count);
+		}
+
+		let unicode = [];
+		let unicodeBinary = [];
+		for (var i = 0, len = binaryArray.length; i < len;) {
+			if (binaryArray[i] === 0) {
+				unicode = unicode.concat(_toDecimal(binaryArray.slice(i, i + 8)));
+				i += 8;
+			} else {
+				let sum = 0;
+				while (i < len) {
+					if (binaryArray[i] === 1) {
+						++sum;
+					} else {
+						break;
+					}
+					++i;
+				}
+				unicodeBinary = unicodeBinary.concat(binaryArray.slice(i + 1, i + 8 - sum));
+				i += 8 - sum;
+				while (sum > 1) {
+					unicodeBinary = unicodeBinary.concat(binaryArray.slice(i + 2, i + 8));
+					i += 8;
+					--sum;
+				}
+				unicode = unicode.concat(_toDecimal(unicodeBinary));
+				unicodeBinary = [];
+			}
+		}
+		// ---------直接转换为结果
+		let strResult = '';
+		for (var i = 0, len = unicode.length; i < len; ++i) {
+			strResult += String.fromCharCode(unicode[i]);
+		}
+		return strResult;
+	}
+};
+
+let rotateLeft = function (lValue, iShiftBits) {
+	return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
+};
+
+let addUnsigned = function (lX, lY) {
+	let lX4, lY4, lX8, lY8, lResult;
+	lX8 = (lX & 0x80000000);
+	lY8 = (lY & 0x80000000);
+	lX4 = (lX & 0x40000000);
+	lY4 = (lY & 0x40000000);
+	lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
+	if (lX4 & lY4) return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
+	if (lX4 | lY4) {
+		if (lResult & 0x40000000) return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
+		else return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
+	} else {
+		return (lResult ^ lX8 ^ lY8);
+	}
+};
+
+let F = function (x, y, z) {
+	return (x & y) | ((~x) & z);
+};
+
+let G = function (x, y, z) {
+	return (x & z) | (y & (~z));
+};
+
+let H = function (x, y, z) {
+	return (x ^ y ^ z);
+};
+
+let I = function (x, y, z) {
+	return (y ^ (x | (~z)));
+};
+
+let FF = function (a, b, c, d, x, s, ac) {
+	a = addUnsigned(a, addUnsigned(addUnsigned(F(b, c, d), x), ac));
+	return addUnsigned(rotateLeft(a, s), b);
+};
+
+let GG = function (a, b, c, d, x, s, ac) {
+	a = addUnsigned(a, addUnsigned(addUnsigned(G(b, c, d), x), ac));
+	return addUnsigned(rotateLeft(a, s), b);
+};
+
+let HH = function (a, b, c, d, x, s, ac) {
+	a = addUnsigned(a, addUnsigned(addUnsigned(H(b, c, d), x), ac));
+	return addUnsigned(rotateLeft(a, s), b);
+};
+
+let II = function (a, b, c, d, x, s, ac) {
+	a = addUnsigned(a, addUnsigned(addUnsigned(I(b, c, d), x), ac));
+	return addUnsigned(rotateLeft(a, s), b);
+};
+
+let convertToWordArray = function (string) {
+	let lWordCount;
+	let lMessageLength = string.length;
+	let lNumberOfWordsTempOne = lMessageLength + 8;
+	let lNumberOfWordsTempTwo = (lNumberOfWordsTempOne - (lNumberOfWordsTempOne % 64)) / 64;
+	let lNumberOfWords = (lNumberOfWordsTempTwo + 1) * 16;
+	let lWordArray = Array(lNumberOfWords - 1);
+	let lBytePosition = 0;
+	let lByteCount = 0;
+	while (lByteCount < lMessageLength) {
+		lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+		lBytePosition = (lByteCount % 4) * 8;
+		lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
+		lByteCount++;
+	}
+	lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+	lBytePosition = (lByteCount % 4) * 8;
+	lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
+	lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
+	lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
+	return lWordArray;
+};
+
+let wordToHex = function (lValue) {
+	let WordToHexValue = '', WordToHexValueTemp = '', lByte, lCount;
+	for (lCount = 0; lCount <= 3; lCount++) {
+		lByte = (lValue >>> (lCount * 8)) & 255;
+		WordToHexValueTemp = '0' + lByte.toString(16);
+		WordToHexValue = WordToHexValue + WordToHexValueTemp.substr(WordToHexValueTemp.length - 2, 2);
+	}
+	return WordToHexValue;
+};
+
+let uTF8Encode = function (str) {
+	str = str.replace(/\x0d\x0a/g, '\x0a');
+	let output = '';
+	for (let n = 0; n < str.length; n++) {
+		let c = str.charCodeAt(n);
+		if (c < 128) {
+			output += String.fromCharCode(c);
+		} else if ((c > 127) && (c < 2048)) {
+			output += String.fromCharCode((c >> 6) | 192);
+			output += String.fromCharCode((c & 63) | 128);
+		} else {
+			output += String.fromCharCode((c >> 12) | 224);
+			output += String.fromCharCode(((c >> 6) & 63) | 128);
+			output += String.fromCharCode((c & 63) | 128);
+		}
+	}
+	return output;
+};
+
+var md5 = function (string) {
+	let x = Array();
+	let k, AA, BB, CC, DD, a, b, c, d;
+	let S11 = 7, S12 = 12, S13 = 17, S14 = 22;
+	let S21 = 5, S22 = 9, S23 = 14, S24 = 20;
+	let S31 = 4, S32 = 11, S33 = 16, S34 = 23;
+	let S41 = 6, S42 = 10, S43 = 15, S44 = 21;
+	string = uTF8Encode(string);
+	x = convertToWordArray(string);
+	a = 0x67452301;
+	b = 0xEFCDAB89;
+	c = 0x98BADCFE;
+	d = 0x10325476;
+	for (k = 0; k < x.length; k += 16) {
+		AA = a;
+		BB = b;
+		CC = c;
+		DD = d;
+		a = FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
+		d = FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
+		c = FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
+		b = FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
+		a = FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
+		d = FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
+		c = FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
+		b = FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
+		a = FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
+		d = FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
+		c = FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
+		b = FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
+		a = FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
+		d = FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
+		c = FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
+		b = FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
+		a = GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
+		d = GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
+		c = GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
+		b = GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
+		a = GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
+		d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
+		c = GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
+		b = GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
+		a = GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
+		d = GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
+		c = GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
+		b = GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
+		a = GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
+		d = GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
+		c = GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
+		b = GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
+		a = HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
+		d = HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
+		c = HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
+		b = HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
+		a = HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
+		d = HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
+		c = HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
+		b = HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
+		a = HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
+		d = HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
+		c = HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
+		b = HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
+		a = HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
+		d = HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
+		c = HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
+		b = HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
+		a = II(a, b, c, d, x[k + 0], S41, 0xF4292244);
+		d = II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
+		c = II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
+		b = II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
+		a = II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
+		d = II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
+		c = II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
+		b = II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
+		a = II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
+		d = II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
+		c = II(c, d, a, b, x[k + 6], S43, 0xA3014314);
+		b = II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
+		a = II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
+		d = II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
+		c = II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
+		b = II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
+		a = addUnsigned(a, AA);
+		b = addUnsigned(b, BB);
+		c = addUnsigned(c, CC);
+		d = addUnsigned(d, DD);
+	}
+	let tempValue = wordToHex(a) + wordToHex(b) + wordToHex(c) + wordToHex(d);
+	return tempValue.toLowerCase();
+};
+let base64EncodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+let base64DecodeChars = new Array(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1);
+/**
+ * base64编码
+ * @param {Object} str
+ */
+function base64encode (str) {
+	let out, i, len;
+	let c1, c2, c3;
+	len = str.length;
+	i = 0;
+	out = '';
+	while (i < len) {
+		c1 = str.charCodeAt(i++) & 0xff;
+		if (i === len) {
+			out += base64EncodeChars.charAt(c1 >> 2);
+			out += base64EncodeChars.charAt((c1 & 0x3) << 4);
+			out += '==';
+			break;
+		}
+		c2 = str.charCodeAt(i++);
+		if (i === len) {
+			out += base64EncodeChars.charAt(c1 >> 2);
+			out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
+			out += base64EncodeChars.charAt((c2 & 0xF) << 2);
+			out += '=';
+			break;
+		}
+		c3 = str.charCodeAt(i++);
+		out += base64EncodeChars.charAt(c1 >> 2);
+		out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
+		out += base64EncodeChars.charAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >> 6));
+		out += base64EncodeChars.charAt(c3 & 0x3F);
+	}
+	return out;
+}
+/**
+ * base64解码
+ * @param {Object} str
+ */
+function base64decode (str) {
+	let c1, c2, c3, c4;
+	let i, len, out;
+	len = str.length;
+	i = 0;
+	out = '';
+	while (i < len) {
+		/* c1 */
+		do {
+			c1 = base64DecodeChars[str.charCodeAt(i++) & 0xff];
+		}
+		while (i < len && c1 === -1);
+		if (c1 === -1) { break; }
+		/* c2 */
+		do {
+			c2 = base64DecodeChars[str.charCodeAt(i++) & 0xff];
+		}
+		while (i < len && c2 === -1);
+		if (c2 === -1) { break; }
+		out += String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4));
+		/* c3 */
+		do {
+			c3 = str.charCodeAt(i++) & 0xff;
+			if (c3 === 61) { return out; }
+			c3 = base64DecodeChars[c3];
+		}
+		while (i < len && c3 === -1);
+		if (c3 === -1) { break; }
+		out += String.fromCharCode(((c2 & 0XF) << 4) | ((c3 & 0x3C) >> 2));
+		/* c4 */
+		do {
+			c4 = str.charCodeAt(i++) & 0xff;
+			if (c4 === 61) { return out; }
+			c4 = base64DecodeChars[c4];
+		}
+		while (i < len && c4 === -1);
+		if (c4 === -1) { break; }
+		out += String.fromCharCode(((c3 & 0x03) << 6) | c4);
+	}
+	return out;
+}
+
+export default CryptoJS;