gy-webcode2 1.0.0

package/scripts/$u.mixin.js

@@ -0,0 +1,27 @@
+import { mapState } from 'vuex'
+import store from "@/store"
+
+// 尝试将用户在根目录中的store/index.js的vuex的state变量，全部加载到全局变量中
+let $uStoreKey = [];
+try{
+	$uStoreKey = store.state ? Object.keys(store.state) : [];
+}catch(e){
+	
+}
+
+export default  {
+	beforeCreate() {
+		// 将vuex方法挂在到$u中
+		// 使用方法为：如果要修改vuex的state中的user.name变量为"史诗" => this.$u.vuex('user.name', '史诗')
+		// 如果要修改vuex的state的version变量为1.0.1 => this.$u.vuex('version', '1.0.1')
+		this.$vuex = (name, value) => {
+			this.$store.commit('$uStore', {
+				name,value
+			})
+		}
+	},
+	computed: {
+		// 将vuex的state中的所有变量，解构到全局混入的mixin中
+		...mapState($uStoreKey)
+	}
+}

package/scripts/crypto.js

@@ -0,0 +1,184 @@
+import CryptoJS from "crypto-js";
+import JSEncrypt from "./jsencrypt"
+
+let publicKey = `MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCHc63H8xcxLRfImQFsa+x1ANC7vIX7GAKAXvz1EE76OWLY0DLc4rlo6wedOu+HzaDSsSTwDCHr8Gi2SXg4DNwyJY12vNK4ZpptHj6BrYqOhxJmExmxMLuyyzAxMiaBWYmGJhHPb1xHoOYaSGd4JkVEfdmkkg5OeqH1ZFhzmK5VIQIDAQAB`
+let privateKey = '这里是封装的私钥'
+
+const sha256 = (data) => {
+    return CryptoJS.SHA256(data).toString();
+};
+
+const crypto = {
+    // 数据加密
+    encrypt(val) {
+        var key = CryptoJS.enc.Utf8.parse(window._zgy.aESKey);
+        let encrypted = CryptoJS.AES.encrypt(val, key,
+            {
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.ZeroPadding
+            });
+        return encrypted.toString();
+    },
+    // 数据解密
+    decrypt(val) {
+        var key = CryptoJS.enc.Utf8.parse(window._zgy.aESKey);
+        let decrypted = CryptoJS.AES.decrypt(val, key,
+            {
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.ZeroPadding
+            });
+        return decrypted.toString(CryptoJS.enc.Utf8);
+    },
+
+    /**
+     * 生成随机字符串
+     * @param len 指定长度
+     */
+    randomString(len) {
+        len = len || 32;
+        let $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';    /****默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1****/
+        let maxPos = $chars.length;
+        let pwd = '';
+        for (let i = 0; i < len; i++) {
+            pwd += $chars.charAt(Math.floor(Math.random() * maxPos));
+        }
+        return pwd;
+    },
+
+    /**
+     * 从1970年开始的毫秒数然后截取10位变成 从1970年开始的秒数
+     * @return 返回10位时间戳
+     */
+    timestamp() {
+        // new Date().getTime();
+        let tmp = Date.parse(new Date()).toString();
+        tmp = tmp.substr(0, 10);
+        return tmp;
+    },
+
+    /**
+     * 签名
+     * @param token 身份令牌
+     * @param timestamp 签名时间戳
+     * @param data 签名数据
+     * @param key 签名key
+     * @param nonce 随机字符串
+     */
+    sign(token, timestamp, data, key, nonce) {
+        let ret = [];
+        let json = {};
+        if(!data || Array.isArray(data)){
+            ret = [];
+        }else if(data.constructor.name == "URLSearchParams"){
+            data.forEach((a,b)=>{
+                if(a != null){
+                    ret.push(b);
+                    json[b] = a;
+                }
+            });
+        }else{
+            for (let it in data) {
+                let val = data[it];
+                if(data[it] != null){
+                    json[it] = val;
+                    if (typeof val === 'object') {
+                        json[it] = '';
+                    }
+                    ret.push(it);
+                }
+            }
+        }
+        // 字典升序
+        ret.sort();
+        var parstring = [];
+        ret.forEach((a,b)=>{
+            parstring.push(a+json[a])
+        });
+        let signsrc = parstring.join('') + token  + timestamp + nonce;
+        return sha256(signsrc).toUpperCase();
+    },
+    //key加密
+    RSAencrypt(pas,key) {
+        if(!pas){
+            return "";
+        }
+        let encryptStr = new JSEncrypt();
+        encryptStr.setPublicKey(key);
+        return encryptStr.encryptLong2(pas.toString());  
+    },
+    //key解密
+    RSAdecrypt(pas,key) {
+        let jse = new JSEncrypt();
+        // 私钥
+        jse.setPrivateKey(key)
+        // console.log('解密：'+jse.decrypt(pas))
+        return jse.decryptLong2(pas);
+
+        // let jse = new JSEncrypt();
+        // // 私钥
+        // jse.setPrivateKey(key)
+        // // console.log('解密：'+jse.decrypt(pas))
+        // return jse.decrypt(pas);
+
+    },
+    //生成公私钥
+    getRsaKeys(func){
+        window.crypto.subtle.generateKey(
+            {
+                name: "RSA-OAEP",
+                modulusLength: 1024, //can be 1024, 2048, or 4096
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: {name: "SHA-256"}, //can be "SHA-1", "SHA-256", "SHA-384", or "SHA-512"
+            },
+            true, //whether the key is extractable (i.e. can be used in exportKey)
+            ["encrypt", "decrypt"] //must be ["encrypt", "decrypt"] or ["wrapKey", "unwrapKey"]
+        ).then(function(key){
+            window.crypto.subtle.exportKey(
+                "pkcs8", 
+                key.privateKey 
+            ).then(function(keydata1){
+                window.crypto.subtle.exportKey(
+                    "spki",
+                    key.publicKey 
+                ).then(function(keydata2){
+                    var privateKey = crypto.RSA2text(keydata1,1);
+                    var publicKey = crypto.RSA2text(keydata2);
+                    func(privateKey,publicKey);
+                }).catch(function(err){
+                    console.error(err);
+                });
+            })
+            .catch(function(err){
+                console.error(err);
+            });
+        })
+        .catch(function(err){
+            console.error(err);
+        });
+    },
+    RSA2text(buffer,isPrivate=0) {
+            var binary = '';
+            var bytes = new Uint8Array(buffer);
+            var len = bytes.byteLength;
+            for (var i = 0; i < len; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+            var base64 = window.btoa(binary);
+            if(isPrivate == 1){
+
+                // var text = "-----BEGIN "+(isPrivate?"PRIVATE":"PUBLIC")+" KEY-----\n";
+                var text = base64.replace(/[^\x00-\xff]/g,"$&\x01").replace(/.{64}\x01?/g,"$&\n");
+                // text += "\n-----END "+(isPrivate?"PRIVATE":"PUBLIC")+" KEY-----";
+            }
+            else{
+                // var text = "-----BEGIN "+(isPrivate?"PRIVATE":"PUBLIC")+" KEY-----\n";
+                var text = base64
+                // .replace(/[^\x00-\xff]/g,"$&\x01").replace(/.{64}\x01?/g,"$&\n");
+                // text += "\n-----END "+(isPrivate?"PRIVATE":"PUBLIC")+" KEY-----";
+            }
+            return text;
+    }
+
+
+}
+export default crypto;

package/scripts/jsencrypt.js

@@ -0,0 +1,180 @@
+var b64map="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var b64pad="=";
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+JSEncrypt.prototype.encryptLong2 = function (string) {
+    var k = this.getKey();
+    // console.log(k);
+    try {
+        var lt = "";
+        var ct = "";
+        //RSA每次加密117bytes，需要辅助方法判断字符串截取位置
+        //1.获取字符串截取点
+        var bytes = new Array();
+        bytes.push(0);
+        var byteNo = 0;
+        var len, c;
+        len = string.length;
+        var temp = 0;
+        for (var i = 0; i < len; i++) {
+            c = string.charCodeAt(i);
+            if (c >= 0x010000 && c <= 0x10FFFF) {
+                byteNo += 4;
+            } else if (c >= 0x000800 && c <= 0x00FFFF) {
+                byteNo += 3;
+            } else if (c >= 0x000080 && c <= 0x0007FF) {
+                byteNo += 2;
+            } else {
+                byteNo += 1;
+            }
+            if ((byteNo % 117) >= 114 || (byteNo % 117) == 0) {
+                if (byteNo - temp >= 114) {
+                    bytes.push(i);
+                    temp = byteNo;
+                }
+            }
+        }
+        //2.截取字符串并分段加密
+        if (bytes.length > 1) {
+            for (var i = 0; i < bytes.length - 1; i++) {
+                var str;
+                if (i == 0) {
+                    str = string.substring(0, bytes[i + 1] + 1);
+                } else {
+                    str = string.substring(bytes[i] + 1, bytes[i + 1] + 1);
+                }
+                var t1 = k.encrypt(str);
+                ct += t1;
+            }
+            ;
+            if (bytes[bytes.length - 1] != string.length - 1) {
+                var lastStr = string.substring(bytes[bytes.length - 1] + 1);
+                ct += k.encrypt(lastStr);
+            }
+            return hex2b64(ct);
+        }
+        var t = k.encrypt(string);
+        var y = hex2b64(t);
+        return y;
+    } catch (ex) {
+        return false;
+    }
+};
+
+JSEncrypt.prototype.decryptLong2 = function (string) {
+    var k = this.getKey();
+    // var maxLength = ((k.n.bitLength()+7)>>3);
+    var MAX_DECRYPT_BLOCK = 128;
+    try {
+        var ct = "";
+        var t1;
+        var bufTmp;
+        var hexTmp;
+        var str = b64tohex(string);
+        var buf = hexToBytes(str);
+        var inputLen = buf.length;
+        //开始长度
+        var offSet = 0;
+        //结束长度
+        var endOffSet = MAX_DECRYPT_BLOCK;
+        //分段加密
+        while (inputLen - offSet > 0) {
+            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
+                bufTmp = buf.slice(offSet, endOffSet);
+                hexTmp = bytesToHex(bufTmp);
+                t1 = k.decrypt(hexTmp);
+                ct += t1;
+
+            } else {
+
+                bufTmp = buf.slice(offSet, inputLen);
+                hexTmp = bytesToHex(bufTmp);
+                t1 = k.decrypt(hexTmp);
+                ct += t1;
+
+            }
+            offSet += MAX_DECRYPT_BLOCK;
+            endOffSet += MAX_DECRYPT_BLOCK;
+        }
+        return ct;
+    } catch (ex) {
+        console.log(ex);
+        return false;
+    }
+};
+
+function hex2b64(h) {
+    var i;
+    var c;
+    var ret = "";
+    for(i = 0; i+3 <= h.length; i+=3) {
+        c = parseInt(h.substring(i,i+3),16);
+        ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63);
+    }
+    if(i+1 == h.length) {
+        c = parseInt(h.substring(i,i+1),16);
+        ret += b64map.charAt(c << 2);
+    }
+    else if(i+2 == h.length) {
+        c = parseInt(h.substring(i,i+2),16);
+        ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);
+    }
+    while((ret.length & 3) > 0) ret += b64pad;
+    return ret;
+}
+function b64tohex(s) {
+    var ret = "";
+    var i;
+    var k = 0; // b64 state, 0-3
+    var slop = 0;
+    for (i = 0; i < s.length; ++i) {
+        if (s.charAt(i) == b64pad) {
+            break;
+        }
+        var v = b64map.indexOf(s.charAt(i));
+        if (v < 0) {
+            continue;
+        }
+        if (k == 0) {
+            ret += int2char(v >> 2);
+            slop = v & 3;
+            k = 1;
+        }
+        else if (k == 1) {
+            ret += int2char((slop << 2) | (v >> 4));
+            slop = v & 0xf;
+            k = 2;
+        }
+        else if (k == 2) {
+            ret += int2char(slop);
+            ret += int2char(v >> 2);
+            slop = v & 3;
+            k = 3;
+        }
+        else {
+            ret += int2char((slop << 2) | (v >> 4));
+            ret += int2char(v & 0xf);
+            k = 0;
+        }
+    }
+    if (k == 1) {
+        ret += int2char(slop << 2);
+    }
+    return ret;
+}
+function hexToBytes(hex) {
+    for (var bytes = [], c = 0; c < hex.length; c += 2)
+        bytes.push(parseInt(hex.substr(c, 2), 16));
+    return bytes;
+}
+function bytesToHex(bytes) {
+    for (var hex = [], i = 0; i < bytes.length; i++) {
+        hex.push((bytes[i] >>> 4).toString(16));
+        hex.push((bytes[i] & 0xF).toString(16));
+    }
+    return hex.join("");
+}
+function int2char(n) {
+    return BI_RM.charAt(n);
+}
+
+export default JSEncrypt;

package/scripts/md5.js

@@ -0,0 +1,259 @@
+let md5 = function(s) {
+  /*
+   * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+   * Digest Algorithm, as defined in RFC 1321.
+   * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+   * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+   * Distributed under the BSD License
+   * See http://pajhome.org.uk/crypt/md5 for more info.
+   */
+
+  /*
+   * Configurable variables. You may need to tweak these to be compatible with
+   * the server-side, but the defaults work in most cases.
+   */
+  var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase        */
+  var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance   */
+  var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode      */
+
+  /*
+   * These are the functions you'll usually want to call
+   * They take string arguments and return either hex or base-64 encoded strings
+   */
+  function hex_md5(s) {
+    return binl2hex(core_md5(str2binl(s), s.length * chrsz));
+  }
+  function b64_md5(s) {
+    return binl2b64(core_md5(str2binl(s), s.length * chrsz));
+  }
+  function str_md5(s) {
+    return binl2str(core_md5(str2binl(s), s.length * chrsz));
+  }
+  function hex_hmac_md5(key, data) {
+    return binl2hex(core_hmac_md5(key, data));
+  }
+  function b64_hmac_md5(key, data) {
+    return binl2b64(core_hmac_md5(key, data));
+  }
+  function str_hmac_md5(key, data) {
+    return binl2str(core_hmac_md5(key, data));
+  }
+
+  /*
+   * Perform a simple self-test to see if the VM is working
+   */
+  function md5_vm_test() {
+    return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
+  }
+
+  /*
+   * Calculate the MD5 of an array of little-endian words, and a bit length
+   */
+  function core_md5(x, len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << len % 32;
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+    var a = 1732584193;
+    var b = -271733879;
+    var c = -1732584194;
+    var d = 271733878;
+
+    for (var i = 0; i < x.length; i += 16) {
+      var olda = a;
+      var oldb = b;
+      var oldc = c;
+      var oldd = d;
+
+      a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
+      d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
+      c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
+      b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
+      a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
+      d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
+      c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
+      b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
+      a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
+      d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
+      c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
+      b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
+      a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
+      d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
+      c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
+      b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
+
+      a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
+      d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
+      c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
+      b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
+      a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
+      d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
+      c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
+      b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
+      a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
+      d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
+      c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
+      b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
+      a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
+      d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
+      c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
+      b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
+
+      a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
+      d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
+      c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
+      b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
+      a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
+      d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
+      c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
+      b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
+      a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
+      d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
+      c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
+      b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
+      a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
+      d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
+      c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
+      b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
+
+      a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
+      d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
+      c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
+      b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
+      a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
+      d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
+      c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
+      b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
+      a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
+      d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
+      c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
+      b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
+      a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
+      d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
+      c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
+      b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
+
+      a = safe_add(a, olda);
+      b = safe_add(b, oldb);
+      c = safe_add(c, oldc);
+      d = safe_add(d, oldd);
+    }
+    return Array(a, b, c, d);
+  }
+
+  /*
+   * These functions implement the four basic operations the algorithm uses.
+   */
+  function md5_cmn(q, a, b, x, s, t) {
+    return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
+  }
+  function md5_ff(a, b, c, d, x, s, t) {
+    return md5_cmn((b & c) | (~b & d), a, b, x, s, t);
+  }
+  function md5_gg(a, b, c, d, x, s, t) {
+    return md5_cmn((b & d) | (c & ~d), a, b, x, s, t);
+  }
+  function md5_hh(a, b, c, d, x, s, t) {
+    return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+  }
+  function md5_ii(a, b, c, d, x, s, t) {
+    return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
+  }
+
+  /*
+   * Calculate the HMAC-MD5, of a key and some data
+   */
+  function core_hmac_md5(key, data) {
+    var bkey = str2binl(key);
+    if (bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
+
+    var ipad = Array(16),
+      opad = Array(16);
+    for (var i = 0; i < 16; i++) {
+      ipad[i] = bkey[i] ^ 0x36363636;
+      opad[i] = bkey[i] ^ 0x5c5c5c5c;
+    }
+
+    var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
+    return core_md5(opad.concat(hash), 512 + 128);
+  }
+
+  /*
+   * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+   * to work around bugs in some JS interpreters.
+   */
+  function safe_add(x, y) {
+    var lsw = (x & 0xffff) + (y & 0xffff);
+    var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xffff);
+  }
+
+  /*
+   * Bitwise rotate a 32-bit number to the left.
+   */
+  function bit_rol(num, cnt) {
+    return (num << cnt) | (num >>> (32 - cnt));
+  }
+
+  /*
+   * Convert a string to an array of little-endian words
+   * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
+   */
+  function str2binl(str) {
+    var bin = Array();
+    var mask = (1 << chrsz) - 1;
+    for (var i = 0; i < str.length * chrsz; i += chrsz) {
+      bin[i >> 5] |= (str.charCodeAt(i / chrsz) & mask) << i % 32;
+    }
+    return bin;
+  }
+
+  /*
+   * Convert an array of little-endian words to a string
+   */
+  function binl2str(bin) {
+    var str = "";
+    var mask = (1 << chrsz) - 1;
+    for (var i = 0; i < bin.length * 32; i += chrsz) {
+      str += String.fromCharCode((bin[i >> 5] >>> i % 32) & mask);
+    }
+    return str;
+  }
+
+  /*
+   * Convert an array of little-endian words to a hex string.
+   */
+  function binl2hex(binarray) {
+    var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+    var str = "";
+    for (var i = 0; i < binarray.length * 4; i++) {
+      str +=
+        hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8 + 4)) & 0xf) +
+        hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8)) & 0xf);
+    }
+    return str;
+  }
+
+  /*
+   * Convert an array of little-endian words to a base-64 string
+   */
+  function binl2b64(binarray) {
+    var tab =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var str = "";
+    for (var i = 0; i < binarray.length * 4; i += 3) {
+      var triplet =
+        (((binarray[i >> 2] >> (8 * (i % 4))) & 0xff) << 16) |
+        (((binarray[(i + 1) >> 2] >> (8 * ((i + 1) % 4))) & 0xff) << 8) |
+        ((binarray[(i + 2) >> 2] >> (8 * ((i + 2) % 4))) & 0xff);
+      for (var j = 0; j < 4; j++) {
+        if (i * 8 + j * 6 > binarray.length * 32) str += b64pad;
+        else str += tab.charAt((triplet >> (6 * (3 - j))) & 0x3f);
+      }
+    }
+    return str;
+  }
+
+  return hex_md5(s);
+};
+export default md5;