接口加密

App.vue

@@ -12,25 +12,25 @@
 			uni.setStorageSync('logs', logs);
 
 			// 获取用户信息
-			uni.getSetting({
-				success: (res) => {
-					if (res.authSetting['scope.userInfo']) {
-						// 已经授权，可以直接调用 getUserInfo 获取头像昵称，不会弹框
-						uni.getUserInfo({
-							success: (res) => {
-								// 可以将 res 发送给后台解码出 unionId
-								this.globalData.userInfo = res.userInfo;
+			// uni.getSetting({
+			// 	success: (res) => {
+			// 		if (res.authSetting['scope.userInfo']) {
+			// 			// 已经授权，可以直接调用 getUserInfo 获取头像昵称，不会弹框
+			// 			uni.getUserInfo({
+			// 				success: (res) => {
+			// 					// 可以将 res 发送给后台解码出 unionId
+			// 					this.globalData.userInfo = res.userInfo;
 
-								// 由于 getUserInfo 是网络请求，可能会在 Page.onLoad 之后才返回
-								// 所以此处加入 callback 以防止这种情况
-								if (this.userInfoReadyCallback) {
-									this.userInfoReadyCallback(res);
-								}
-							}
-						});
-					}
-				}
-			});
+			// 					// 由于 getUserInfo 是网络请求，可能会在 Page.onLoad 之后才返回
+			// 					// 所以此处加入 callback 以防止这种情况
+			// 					if (this.userInfoReadyCallback) {
+			// 						this.userInfoReadyCallback(res);
+			// 					}
+			// 				}
+			// 			});
+			// 		}
+			// 	}
+			// });
 		},
 		globalData: {
 			userInfo: null,

README.md

@@ -85,3 +85,8 @@ https://uniapp.dcloud.io/tutorial/miniprogram-subject.html#%E5%B0%8F%E7%A8%8B%E5
 ### 其他
 - 因各种原因，本工具并非100%完美转换！有问题实属正常！
 - 如遇运行报错，请在https://github.com/zhangdaren/miniprogram-to-uniapp，将详细情况提交Issue！
+
+
+wx8fef5f0844535860
+
+wx4e337f60e395754c
\ No newline at end of file

api/http.js

-/**
- * http 请求封装
- * @author tangsj
- * @param {*} url  请求地址
- * @param {*} options 请求参数
- */
-import config from '../config';
-import utils from '../utils';
-
-// 记录请求中的请求数，控制loading显示
-let requestCount = 0;
-let hasError = false;
-
-export function fetch(url, options) {
-
-  const header = {
-	key: 'bdc27dab6487a7f4b94cefdfea8da8b8',
-	token: 'bdc27dab6487a7f4b94cefdfea8da8b8',
-    propertyId: config.propertyId,
-  };
-  if(uni.getStorageSync('token')){
-	  header['token'] = uni.getStorageSync('token')
-  }
-  options = Object.assign({
-    loading: true,
-    method: 'GET',
-    data: {},
-    holdTip: false,
-  }, options);
-
-  return new Promise((resolve, reject) => {
-    if (requestCount === 0 && options.loading) {
-      hasError = false;
-      uni.showLoading({
-        title: '加载中...',
-      });
-    }
-    requestCount += 1;
-    uni.request({
-      url: `${config.apiRoot}${url}`,
-      data: options.data,
-      method: options.method,
-      header,
-      success: (res) => {
-		  console.log(res)
-        if (+res.data.code !== 200) {
-			if(res.data.message === '登录过期，请重新登录!'){
-				console.log("fdsa")
-				uni.removeStorageSync('token');
-				uni.reLaunch({
-					url: '/basicsPage/login/index',
-				});
-			}
-          if (!options.holdTip) {
-            uni.showToast({
-              title: res.message || '服务器异常！',
-              icon: 'none',
-            });
-            hasError = true;
-          }
-          return reject(res.data || {});
-        }
-
-        return resolve(res.data || {});
-      },
-      fail: (err) => {
-		  console.log(err);
-        hasError = true;
-
-        uni.showToast({
-          title: '服务器异常！',
-          icon: 'none',
-        });
-
-        reject({
-          msg: '服务器异常！',
-        });
-      },
-      complete: () => {
-        requestCount -= 1;
-        if (requestCount === 0 && options.loading) {
-          if (hasError) {
-            setTimeout(() => {
-              uni.hideLoading();
-            }, 2000);
-          } else {
-            uni.hideLoading();
-          }
-        }
-      },
-    });
-  });
-}
-
-const http = {
-  get(url, data = {}, options = {}) {
-    return fetch(url, {
-      method: 'GET',
-      data: data.params,
-      ...options,
-    });
-  },
-  post(url, data = {}, options = {}) {
-    if (data.params) {
-      // 将param放到url 参数里面
-      const query = utils.buildQueryString(data.params);
-      url += `?${query}`;
-      delete data.params;
-    }
-    return fetch(url, {
-      method: 'POST',
-      data,
-      ...options,
-    });
-  },
-};
-
-export default http;
+/**
+ * http 请求封装
+ * @author tangsj
+ * @param {*} url  请求地址
+ * @param {*} options 请求参数
+ */
+import config from '../config';
+import utils from '../utils';
+import md5 from 'md5';
+import CryptoJS from 'crypto-js';
+
+// 记录请求中的请求数，控制loading显示
+let requestCount = 0;
+let hasError = false;
+
+export function fetch(url, options) {
+
+	const header = {
+		key: 'bdc27dab6487a7f4b94cefdfea8da8b8',
+		token: 'bdc27dab6487a7f4b94cefdfea8da8b8',
+		propertyId: config.propertyId,
+	};
+	if (uni.getStorageSync('token')) {
+		header['token'] = uni.getStorageSync('token')
+	}
+	options = Object.assign({
+		loading: true,
+		method: 'GET',
+		data: {},
+		holdTip: false,
+	}, options);
+
+	options.data = {
+		...options.data,
+		timestamp: Math.round(new Date().getTime() / 1000),
+		nonce_str: generateRandomString(6)
+	}
+
+	let sign = getDataSign(options.data)
+
+	options.data = {
+		...options.data,
+		sign: sign
+	}
+
+	return new Promise((resolve, reject) => {
+		if (requestCount === 0 && options.loading) {
+			hasError = false;
+			uni.showLoading({
+				title: '加载中...',
+			});
+		}
+		requestCount += 1;
+		uni.request({
+			url: `${config.apiRoot}${url}`,
+			data: options.data,
+			method: options.method,
+			header,
+			success: (res) => {
+				console.log(res)
+				let resData = res.data
+				let aesResObj
+				if (resData && typeof(resData) == 'string') {
+					aesResObj = resultCryptoJS(resData, res)
+					// return resolve(aesResObj || {});
+					// console.log(decryptedFn());
+				} else {
+					aesResObj = res
+				}
+
+				console.log(aesResObj.data);
+				
+				if (+aesResObj.data.code !== 200) {
+					if (aesResObj.data.message === '登录过期，请重新登录!') {
+						console.log("fdsa")
+						uni.removeStorageSync('token');
+						uni.reLaunch({
+							url: '/basicsPage/login/index',
+						});
+					}
+					if (!options.holdTip) {
+						uni.showToast({
+							title: aesResObj.data.message || '服务器异常！',
+							icon: 'none',
+						});
+						hasError = true;
+					}
+					return reject(aesResObj || {});
+				}
+
+				return resolve(aesResObj || {});
+
+			},
+			fail: (err) => {
+				console.log(err);
+				hasError = true;
+
+				uni.showToast({
+					title: '服务器异常！',
+					icon: 'none',
+				});
+
+				reject({
+					msg: '服务器异常！',
+				});
+			},
+			complete: () => {
+				requestCount -= 1;
+				if (requestCount === 0 && options.loading) {
+					if (hasError) {
+						setTimeout(() => {
+							uni.hideLoading();
+						}, 2000);
+					} else {
+						uni.hideLoading();
+					}
+				}
+			},
+		});
+	});
+}
+
+const resultCryptoJS = (resData, res) => {
+	let decryptedFn = (word) => {
+		// let word = 'MYXCBCRv+hJq3/vG7SqtDQ==';
+		let keyStr = '7ff174ec45ecb7b5';
+		let ivStr = '7ee42dd0ad6610ae';
+		let key;
+		let iv;
+
+		if (keyStr) {
+			key = CryptoJS.enc.Utf8.parse(keyStr);
+			iv = CryptoJS.enc.Utf8.parse(ivStr);
+		}
+		const base64 = CryptoJS.enc.Base64.parse(word);
+		const src = CryptoJS.enc.Base64.stringify(base64);
+		const decrypted = CryptoJS.AES.decrypt(src, key, {
+			iv, // 偏移量
+			mode: CryptoJS.mode.CBC,
+			padding: CryptoJS.pad.Pkcs7
+			// padding: CryptoJS.pad.ZeroPadding
+		});
+
+		const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
+
+		return decryptedStr.toString();
+	}
+	let aesRes = decryptedFn(resData)
+	let aesResObj
+	try {
+		aesResObj = {
+			...res,
+			data: JSON.parse(aesRes)
+		}
+	} catch (e) {
+		// console.log(e);
+		aesResObj = {
+			...res
+			// ...res.data,
+			// data: res.data.data || {}
+		}
+		//TODO handle the exception
+	}
+	return aesResObj
+}
+const generateRandomString = (length) => {
+	const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+	let result = '';
+	for (let i = 0; i < length; i++) {
+		const randomIndex = Math.floor(Math.random() * characters.length);
+		result += characters[randomIndex];
+	}
+	return result;
+}
+const getDataSign = (datas) => {
+	let arr = []
+	for (let key in datas) {
+		if (datas[key]) {
+			arr.push({
+				key: key,
+				val: datas[key]
+			})
+		}
+	}
+
+	// arr.sort((a, b) => a.key.charCodeAt(0) - b.key.charCodeAt(0))
+	arr.sort((a, b) => a.key.localeCompare(b.key))
+	let res = arr.map(item => `${item.key}=${item.val}`)
+	// console.log(arr);
+	let stringA = res.join('&')
+	let stringSignTemp = stringA + "&key=2B39F1EBCD77E7917AA28BAA8C3AA71A"
+	// console.log(stringSignTemp);
+	let sign = md5(stringSignTemp).toUpperCase()
+	// console.log(sign);
+	return sign
+}
+
+const http = {
+	get(url, data = {}, options = {}) {
+		return fetch(url, {
+			method: 'GET',
+			data: data.params,
+			...options,
+		});
+	},
+	post(url, data = {}, options = {}) {
+		if (data.params) {
+			// 将param放到url 参数里面
+			const query = utils.buildQueryString(data.params);
+			url += `?${query}`;
+			delete data.params;
+		}
+		return fetch(url, {
+			method: 'POST',
+			data,
+			...options,
+		});
+	},
+};
+
+export default http;
\ No newline at end of file

api/main.js

@@ -27,6 +27,138 @@ export default {
 	visitorQrcode(data) {
 		return http.post('/api/entrance_guard/visitorQrcode', data);
 	},
+
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	parkingIndex(params) {
+		return http.get('/api/parking/index', {
+			params
+		});
+	},
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	parkingUsercar(params) {
+		return http.get('/api/parking/usercar', {
+			params
+		});
+	},
+
+
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	parkingGetCarInfo(params) {
+		return http.get('/api/parking/getCarInfo', {
+			params
+		});
+	},
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	parkingGetopenid(params) {
+		return http.get('/api/parking/getopenid', {
+			params
+		});
+	},
+
+
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	parkingUsercardel(data) {
+		return http.post('/api/parking/usercardel', data);
+	},
+
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	parkingParkingList(params) {
+		return http.get('/api/parking/parkingList', {
+			params
+		});
+	},
+
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	parkingUsercaradd(data) {
+		return http.post('/api/parking/usercaradd', data);
+	},
+
+
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	createTempOrder(data) {
+		return http.post('/api/parking/createTempOrder', data);
+	},
+
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	payMini(data) {
+		return http.post('/api/pay/mini', data);
+	},
+
+	/**
+	 * 
+	 * @param {*} data
+	 * @returns
+	 */
+	invoiceGetinvoice(params) {
+		return http.get('/api/invoice/getinvoice', {
+			params
+		});
+	},
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	invoiceTempbilling(data) {
+		return http.post('/api/invoice/tempbilling', data);
+	},
+
+	// /**
+	//  * 
+	//  * @param {*} data
+	//  * @returns
+	//  */
+	// parkingGetcoupon(params) {
+	// 	return http.get('/api/parking/getcoupon', {
+	// 		params
+	// 	});
+	// },
+
+	/**
+	 * 
+	 * @param {*} data 
+	 * @returns 
+	 */
+	parkingGetcoupon(data) {
+		return http.post('/api/parking/getcoupon', data);
+	},
+
 	// /**
 	//  * 获取用户信息
 	//  * @returns 

config/development.js

@@ -7,8 +7,9 @@ const phpRoot = '';
 
 // const baseUrl = 'https://pmdc.hklcn.com'; // 本地
 const baseUrl = 'https://hkland.kupurui.cn'; // 测试服
-// const baseUrl = 'https://pmdc.hklcn.com'; // 正式服
-const imageView = 'https://hkland.kupurui.cn'; // 测试服
+const imageView = 'https://hkland.kupurui.cn'; // 测试服
+
+// const baseUrl = 'https://pmdc.hklcn.com'; // 正式服
 // const imageView = 'https://pmdc.hklcn.com'; // 正式服
 
 export default {

config/production.js

@@ -4,11 +4,10 @@ const baseUrl = '';
 const phpRoot = '';
 
 // const baseUrl = 'https://pmdc.hklcn.com'; // 本地
-// const baseUrl = 'https://hkland.kupurui.cn'; // 测试服
-const baseUrl = 'https://pmdc.hklcn.com'; // 正式服
-
-// const imageView = 'https://hkland.kupurui.cn'; // 测试服
-const imageView = 'https://pmdc.hklcn.com'; // 正式服
+const baseUrl = 'https://hkland.kupurui.cn'; // 测试服
+const imageView = 'https://hkland.kupurui.cn'; // 测试服
+// const baseUrl = 'https://pmdc.hklcn.com'; // 正式服
+// const imageView = 'https://pmdc.hklcn.com'; // 正式服
 
 export default {
 	baseUrl,

manifest.json

@@ -42,7 +42,7 @@
     },
     "quickapp" : {},
     "mp-weixin" : {
-        "appid" : "wx4e337f60e395754c",
+        "appid" : "wx8fef5f0844535860",
         "setting" : {
             "urlCheck" : false
         },

node_modules/.package-lock.json

+{
+	"name": "怡置物业",
+	"version": "1.0.0",
+	"lockfileVersion": 2,
+	"requires": true,
+	"packages": {
+		"node_modules/charenc": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmmirror.com/charenc/-/charenc-0.0.2.tgz",
+			"integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==",
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/crypt": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmmirror.com/crypt/-/crypt-0.0.2.tgz",
+			"integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==",
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/crypto-js": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmmirror.com/crypto-js/-/crypto-js-4.2.0.tgz",
+			"integrity": "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q=="
+		},
+		"node_modules/is-buffer": {
+			"version": "1.1.6",
+			"resolved": "https://registry.npmmirror.com/is-buffer/-/is-buffer-1.1.6.tgz",
+			"integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w=="
+		},
+		"node_modules/md5": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmmirror.com/md5/-/md5-2.3.0.tgz",
+			"integrity": "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==",
+			"dependencies": {
+				"charenc": "0.0.2",
+				"crypt": "0.0.2",
+				"is-buffer": "~1.1.6"
+			}
+		}
+	}
+}

node_modules/charenc/LICENSE.mkd

+Copyright © 2011, Paul Vorbach. All rights reserved.
+Copyright © 2009, Jeff Mott. All rights reserved.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name Crypto-JS nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/charenc/README.js

+**enc** provides crypto character encoding utilities.

node_modules/charenc/charenc.js

+var charenc = {
+  // UTF-8 encoding
+  utf8: {
+    // Convert a string to a byte array
+    stringToBytes: function(str) {
+      return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+    },
+
+    // Convert a byte array to a string
+    bytesToString: function(bytes) {
+      return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+    }
+  },
+
+  // Binary encoding
+  bin: {
+    // Convert a string to a byte array
+    stringToBytes: function(str) {
+      for (var bytes = [], i = 0; i < str.length; i++)
+        bytes.push(str.charCodeAt(i) & 0xFF);
+      return bytes;
+    },
+
+    // Convert a byte array to a string
+    bytesToString: function(bytes) {
+      for (var str = [], i = 0; i < bytes.length; i++)
+        str.push(String.fromCharCode(bytes[i]));
+      return str.join('');
+    }
+  }
+};
+
+module.exports = charenc;

node_modules/charenc/package.json

+{
+  "author": "Paul Vorbach <paul@vorb.de> (http://vorb.de)",
+  "name": "charenc",
+  "description": "character encoding utilities",
+  "tags": [
+    "utf8",
+    "binary",
+    "byte",
+    "string"
+  ],
+  "version": "0.0.2",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/pvorb/node-charenc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pvorb/node-charenc/issues"
+  },
+  "main": "charenc.js",
+  "engines": {
+    "node": "*"
+  }
+}

node_modules/crypt/LICENSE.mkd

+Copyright © 2011, Paul Vorbach. All rights reserved.
+Copyright © 2009, Jeff Mott. All rights reserved.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name Crypto-JS nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/crypt/README.mkd

+**crypt** provides utilities for encryption and hashing

node_modules/crypt/crypt.js

+(function() {
+  var base64map
+      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+
+  crypt = {
+    // Bit-wise rotation left
+    rotl: function(n, b) {
+      return (n << b) | (n >>> (32 - b));
+    },
+
+    // Bit-wise rotation right
+    rotr: function(n, b) {
+      return (n << (32 - b)) | (n >>> b);
+    },
+
+    // Swap big-endian to little-endian and vice versa
+    endian: function(n) {
+      // If number given, swap endian
+      if (n.constructor == Number) {
+        return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;
+      }
+
+      // Else, assume array and swap all items
+      for (var i = 0; i < n.length; i++)
+        n[i] = crypt.endian(n[i]);
+      return n;
+    },
+
+    // Generate an array of any length of random bytes
+    randomBytes: function(n) {
+      for (var bytes = []; n > 0; n--)
+        bytes.push(Math.floor(Math.random() * 256));
+      return bytes;
+    },
+
+    // Convert a byte array to big-endian 32-bit words
+    bytesToWords: function(bytes) {
+      for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
+        words[b >>> 5] |= bytes[i] << (24 - b % 32);
+      return words;
+    },
+
+    // Convert big-endian 32-bit words to a byte array
+    wordsToBytes: function(words) {
+      for (var bytes = [], b = 0; b < words.length * 32; b += 8)
+        bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
+      return bytes;
+    },
+
+    // Convert a byte array to a hex string
+    bytesToHex: function(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('');
+    },
+
+    // Convert a hex string to a byte array
+    hexToBytes: function(hex) {
+      for (var bytes = [], c = 0; c < hex.length; c += 2)
+        bytes.push(parseInt(hex.substr(c, 2), 16));
+      return bytes;
+    },
+
+    // Convert a byte array to a base-64 string
+    bytesToBase64: function(bytes) {
+      for (var base64 = [], i = 0; i < bytes.length; i += 3) {
+        var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        for (var j = 0; j < 4; j++)
+          if (i * 8 + j * 6 <= bytes.length * 8)
+            base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
+          else
+            base64.push('=');
+      }
+      return base64.join('');
+    },
+
+    // Convert a base-64 string to a byte array
+    base64ToBytes: function(base64) {
+      // Remove non-base-64 characters
+      base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
+
+      for (var bytes = [], i = 0, imod4 = 0; i < base64.length;
+          imod4 = ++i % 4) {
+        if (imod4 == 0) continue;
+        bytes.push(((base64map.indexOf(base64.charAt(i - 1))
+            & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))
+            | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));
+      }
+      return bytes;
+    }
+  };
+
+  module.exports = crypt;
+})();

node_modules/crypt/package.json

+{
+  "author": "Paul Vorbach <paul@vorb.de> (http://vorb.de)",
+  "name": "crypt",
+  "description": "utilities for encryption and hashing",
+  "tags": [
+    "hash",
+    "security"
+  ],
+  "version": "0.0.2",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/pvorb/node-crypt.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pvorb/node-crypt/issues"
+  },
+  "main": "crypt.js",
+  "engines": {
+    "node": "*"
+  }
+}

node_modules/crypto-js/CONTRIBUTING.md

+# Contribution
+
+# Git Flow 
+
+The crypto-js project uses [git flow](https://github.com/nvie/gitflow) to manage branches. 
+Do your changes on the `develop` or even better on a `feature/*` branch. Don't do any changes on the `master` branch.
+
+# Pull request
+
+Target your pull request on `develop` branch. Other pull request won't be accepted.
+
+# How to build
+
+1. Clone
+
+2. Run
+
+    ```sh
+    npm install
+    ```
+
+3. Run
+
+    ```sh
+    npm run build
+    ```
+    
+4. Check `build` folder
\ No newline at end of file

node_modules/crypto-js/LICENSE

+# License
+
+[The MIT License (MIT)](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2009-2013 Jeff Mott  
+Copyright (c) 2013-2016 Evan Vosberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/crypto-js/README.md

+# crypto-js
+
+JavaScript library of crypto standards.
+
+## Discontinued
+
+Active development of CryptoJS has been discontinued. This library is no longer maintained.
+
+Nowadays, NodeJS and modern browsers have a native `Crypto` module. The latest version of CryptoJS already uses the native Crypto module for random number generation, since `Math.random()` is not crypto-safe. Further development of CryptoJS would result in it only being a wrapper of native Crypto. Therefore, development and maintenance has been discontinued, it is time to go for the native `crypto` module.
+
+## Node.js (Install)
+
+Requirements:
+
+- Node.js
+- npm (Node.js package manager)
+
+```bash
+npm install crypto-js
+```
+
+### Usage
+
+ES6 import for typical API call signing use case:
+
+```javascript
+import sha256 from 'crypto-js/sha256';
+import hmacSHA512 from 'crypto-js/hmac-sha512';
+import Base64 from 'crypto-js/enc-base64';
+
+const message, nonce, path, privateKey; // ...
+const hashDigest = sha256(nonce + message);
+const hmacDigest = Base64.stringify(hmacSHA512(path + hashDigest, privateKey));
+```
+
+Modular include:
+
+```javascript
+var AES = require("crypto-js/aes");
+var SHA256 = require("crypto-js/sha256");
+...
+console.log(SHA256("Message"));
+```
+
+Including all libraries, for access to extra methods:
+
+```javascript
+var CryptoJS = require("crypto-js");
+console.log(CryptoJS.HmacSHA1("Message", "Key"));
+```
+
+## Client (browser)
+
+Requirements:
+
+- Node.js
+- Bower (package manager for frontend)
+
+```bash
+bower install crypto-js
+```
+
+### Usage
+
+Modular include:
+
+```javascript
+require.config({
+    packages: [
+        {
+            name: 'crypto-js',
+            location: 'path-to/bower_components/crypto-js',
+            main: 'index'
+        }
+    ]
+});
+
+require(["crypto-js/aes", "crypto-js/sha256"], function (AES, SHA256) {
+    console.log(SHA256("Message"));
+});
+```
+
+Including all libraries, for access to extra methods:
+
+```javascript
+// Above-mentioned will work or use this simple form
+require.config({
+    paths: {
+        'crypto-js': 'path-to/bower_components/crypto-js/crypto-js'
+    }
+});
+
+require(["crypto-js"], function (CryptoJS) {
+    console.log(CryptoJS.HmacSHA1("Message", "Key"));
+});
+```
+
+### Usage without RequireJS
+
+```html
+<script type="text/javascript" src="path-to/bower_components/crypto-js/crypto-js.js"></script>
+<script type="text/javascript">
+    var encrypted = CryptoJS.AES(...);
+    var encrypted = CryptoJS.SHA256(...);
+</script>
+```
+
+## API
+
+See: https://cryptojs.gitbook.io/docs/
+
+### AES Encryption
+
+#### Plain text encryption
+
+```javascript
+var CryptoJS = require("crypto-js");
+
+// Encrypt
+var ciphertext = CryptoJS.AES.encrypt('my message', 'secret key 123').toString();
+
+// Decrypt
+var bytes  = CryptoJS.AES.decrypt(ciphertext, 'secret key 123');
+var originalText = bytes.toString(CryptoJS.enc.Utf8);
+
+console.log(originalText); // 'my message'
+```
+
+#### Object encryption
+
+```javascript
+var CryptoJS = require("crypto-js");
+
+var data = [{id: 1}, {id: 2}]
+
+// Encrypt
+var ciphertext = CryptoJS.AES.encrypt(JSON.stringify(data), 'secret key 123').toString();
+
+// Decrypt
+var bytes  = CryptoJS.AES.decrypt(ciphertext, 'secret key 123');
+var decryptedData = JSON.parse(bytes.toString(CryptoJS.enc.Utf8));
+
+console.log(decryptedData); // [{id: 1}, {id: 2}]
+```
+
+### List of modules
+
+
+- ```crypto-js/core```
+- ```crypto-js/x64-core```
+- ```crypto-js/lib-typedarrays```
+
+---
+
+- ```crypto-js/md5```
+- ```crypto-js/sha1```
+- ```crypto-js/sha256```
+- ```crypto-js/sha224```
+- ```crypto-js/sha512```
+- ```crypto-js/sha384```
+- ```crypto-js/sha3```
+- ```crypto-js/ripemd160```
+
+---
+
+- ```crypto-js/hmac-md5```
+- ```crypto-js/hmac-sha1```
+- ```crypto-js/hmac-sha256```
+- ```crypto-js/hmac-sha224```
+- ```crypto-js/hmac-sha512```
+- ```crypto-js/hmac-sha384```
+- ```crypto-js/hmac-sha3```
+- ```crypto-js/hmac-ripemd160```
+
+---
+
+- ```crypto-js/pbkdf2```
+
+---
+
+- ```crypto-js/aes```
+- ```crypto-js/tripledes```
+- ```crypto-js/rc4```
+- ```crypto-js/rabbit```
+- ```crypto-js/rabbit-legacy```
+- ```crypto-js/evpkdf```
+
+---
+
+- ```crypto-js/format-openssl```
+- ```crypto-js/format-hex```
+
+---
+
+- ```crypto-js/enc-latin1```
+- ```crypto-js/enc-utf8```
+- ```crypto-js/enc-hex```
+- ```crypto-js/enc-utf16```
+- ```crypto-js/enc-base64```
+
+---
+
+- ```crypto-js/mode-cfb```
+- ```crypto-js/mode-ctr```
+- ```crypto-js/mode-ctr-gladman```
+- ```crypto-js/mode-ofb```
+- ```crypto-js/mode-ecb```
+
+---
+
+- ```crypto-js/pad-pkcs7```
+- ```crypto-js/pad-ansix923```
+- ```crypto-js/pad-iso10126```
+- ```crypto-js/pad-iso97971```
+- ```crypto-js/pad-zeropadding```
+- ```crypto-js/pad-nopadding```
+
+
+## Release notes
+
+### 4.2.0
+
+Change default hash algorithm and iteration's for PBKDF2 to prevent weak security by using the default configuration.
+
+Custom KDF Hasher
+
+Blowfish support
+
+### 4.1.1
+
+Fix module order in bundled release.
+
+Include the browser field in the released package.json.
+
+### 4.1.0
+
+Added url safe variant of base64 encoding. [357](https://github.com/brix/crypto-js/pull/357)
+
+Avoid webpack to add crypto-browser package. [364](https://github.com/brix/crypto-js/pull/364)
+
+### 4.0.0
+
+This is an update including breaking changes for some environments.
+
+In this version `Math.random()` has been replaced by the random methods of the native crypto module.
+
+For this reason CryptoJS might not run in some JavaScript environments without native crypto module. Such as IE 10 or before or React Native.
+
+### 3.3.0
+
+Rollback, `3.3.0` is the same as `3.1.9-1`.
+
+The move of using native secure crypto module will be shifted to a new `4.x.x` version. As it is a breaking change the impact is too big for a minor release.
+
+### 3.2.1
+
+The usage of the native crypto module has been fixed. The import and access of the native crypto module has been improved.
+
+### 3.2.0
+
+In this version `Math.random()` has been replaced by the random methods of the native crypto module.
+
+For this reason CryptoJS might does not run in some JavaScript environments without native crypto module. Such as IE 10 or before.
+
+If it's absolute required to run CryptoJS in such an environment, stay with `3.1.x` version. Encrypting and decrypting stays compatible. But keep in mind `3.1.x` versions still use `Math.random()` which is cryptographically not secure, as it's not random enough. 
+
+This version came along with `CRITICAL` `BUG`. 
+
+DO NOT USE THIS VERSION! Please, go for a newer version!
+
+### 3.1.x
+
+The `3.1.x` are based on the original CryptoJS, wrapped in CommonJS modules.
+
+

node_modules/crypto-js/aes.js

+;(function (root, factory, undef) {
+	if (typeof exports === "object") {
+		// CommonJS
+		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
+	}
+	else if (typeof define === "function" && define.amd) {
+		// AMD
+		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
+	}
+	else {
+		// Global (browser)
+		factory(root.CryptoJS);
+	}
+}(this, function (CryptoJS) {
+
+	(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);
+	}());
+
+
+	return CryptoJS.AES;
+
+}));
\ No newline at end of file