@lingxiteam/ebe-utils 0.0.33 → 0.0.37

package/lib/public/src/utils/Security/types.ts

@@ -1,8 +1,6 @@
-type requester = 'fetch' | 'xhr' | 'wxRequest';
+export type requester = 'fetch' | 'xhr' | 'wxRequest';
 
 export const enum MODE {
-  // 参数签名(旧数据)
-  SIGN_KEY = 'signKey',
   // 参数签名
   SIGN = '1.0',
   // 时间限制性签名
@@ -17,21 +15,17 @@ export const enum MODE {
   RSA = '2.0',
   // AES参数加密
   AES = '3.0',
-  // DES参数加密
-  DES = '4.0',
 }
 
+export type modeType = `${(typeof MODE)[keyof typeof MODE]}`;
+
 // 自定义加解密函数
 type EncryptionFunctionType = (
   content: string,
   key: string,
-  CryptoJS: CryptoJS,
+  CryptoJS: any,
 ) => string;
 
-export type fnDESEncryptType = EncryptionFunctionType;
-
-export type fnDESDecryptType = EncryptionFunctionType;
-
 export type fnAESEncryptType = EncryptionFunctionType;
 
 export type fnAESDecryptType = EncryptionFunctionType;
@@ -39,13 +33,13 @@ export type fnAESDecryptType = EncryptionFunctionType;
 export type fnRSAEncryptType = (
   content: string,
   publicKey: string,
-  JSEncrypt: JSEncrypt,
+  JSEncrypt: any,
 ) => string;
 
 export type fnRSADecryptType = (
   content: string,
   privKey: string,
-  JSEncrypt: JSEncrypt,
+  JSEncrypt: any,
 ) => string;
 
 export declare namespace encipherOptionType {
@@ -54,7 +48,7 @@ export declare namespace encipherOptionType {
     saltKey?: string;
     saltValue?: string | Function;
     valueKeyName?: string;
-    includeHeaders?: string[];
+    headerKeys?: string[];
   }
   interface aes {
     key?: string;
@@ -62,12 +56,6 @@ export declare namespace encipherOptionType {
     decrypt?: fnAESDecryptType;
   }
 
-  interface des {
-    key?: string;
-    encrypt?: fnDESEncryptType;
-    decrypt?: fnDESDecryptType;
-  }
-
   interface rsa {
     privKey?: string;
     publicKey?: string;
@@ -78,13 +66,12 @@ export declare namespace encipherOptionType {
 
 type ignoreSupportType = string | RegExp | Function;
 export interface configType {
-  mode?: MODE;
+  mode?: modeType;
   securityHeaderKey?: string;
   requester?: requester | requester[];
   ignore?: ignoreSupportType | ignoreSupportType[];
   sign?: encipherOptionType.sign;
   aes?: encipherOptionType.aes;
-  des?: encipherOptionType.des;
   rsa?: encipherOptionType.rsa;
   timeDeviation?: number;
   debug?: boolean;
@@ -108,72 +95,3 @@ export interface signHttpOptionsType {
   search?: string | any;
   saltValue?: string;
 }
-
-namespace securityType {
-  export interface httpEncryption {
-    start: (startConfig?: configType) => void;
-    stop: () => void;
-  }
-
-  export function createHttpSignStr(
-    url: string,
-    options: signHttpOptionsType,
-    version?: any,
-  ): string;
-
-  export function createHttpSignWithUrl(
-    url: string,
-    options?: signHttpOptionsType,
-    version?: any,
-  ): string;
-
-  export function RSAEncrypt(
-    content: string,
-    publicKey: string,
-    handle?: fnRSAEncryptType,
-  ): string;
-
-  export function RSADecrypt(
-    content: string,
-    privKey: string,
-    handle?: fnRSADecryptType,
-  ): string;
-
-  export function AESEncrypt(
-    content: string,
-    aesKey: string,
-    handle?: fnAESEncryptType,
-  ): string;
-
-  export function AESDecrypt(
-    content: string,
-    aesKey: string,
-    handle?: fnAESDecryptType,
-  ): string;
-
-  export function DESEncrypt(
-    content: string,
-    desKey: string,
-    handle?: fnDESEncryptType,
-  ): string;
-
-  export function DESDecrypt(
-    content: string,
-    desKey: string,
-    handle?: fnDESDecryptType,
-  ): string;
-
-  export function setConfig(config: configType): void;
-
-  export function lxEncrypt(str: string): string;
-
-  export type httpEncryptionConfigType = typeof configType;
-
-  export type KEYS = {
-    signKey: string;
-    rsaPublicKey: string;
-    rsaPrivKey: string;
-    aesKey: string;
-    desKey: string;
-  };
-}

package/lib/public/src/utils/Security/urlEncryption.ts

@@ -0,0 +1,108 @@
+import config from './config';
+import { securityHeaderKey, signHeaderKey } from './const';
+import { createHttpSignStr } from './encipher/sign';
+import { MODE, modeType, securityType } from './types';
+import { checkIsEncryption, checkIsSignMode } from './utils/check';
+import {
+  decryptedStrForSearchParams,
+  encryptedStrForSearchParams,
+} from './utils/encrypted';
+import message from './utils/message';
+import { getSearchObj, removeURLParameters } from './utils/url';
+
+export const createHttpSignWithUrl: typeof securityType.createHttpSignWithUrl =
+  (url, options = {}, version) => {
+    if (!url) {
+      return '';
+    }
+    if (version && !checkIsSignMode(version)) {
+      message.warn(`不支持[${version}]签名模式`);
+      return url;
+    }
+    let _url = url;
+    const signVersion =
+      version ||
+      (checkIsSignMode(config.mode as MODE)
+        ? config.mode
+        : MODE.SIGN_WITH_TIME);
+    const signStr = createHttpSignStr(
+      url,
+      { method: 'GET', ...options },
+      signVersion,
+    );
+    // 如果url上存在签名则移除原签名
+    if (
+      url.indexOf(signHeaderKey) !== -1 ||
+      url.indexOf(securityHeaderKey) !== -1
+    ) {
+      _url = removeURLParameters(url, [signHeaderKey, securityHeaderKey]);
+    }
+    return `${_url}${
+      _url.includes('?') ? '&' : '?'
+    }${signHeaderKey}=${signStr}&${securityHeaderKey}=${signVersion}`;
+  };
+
+/**
+ * 将url里的参数进行加密
+ * @param url url地址
+ * @param version 加密模式
+ * @returns 加密处理后的url地址(带加密模式标记)
+ */
+export const createEncryptedWithUrl: typeof securityType.createEncryptedWithUrl =
+  (url, version) => {
+    if (!url) {
+      return '';
+    }
+    if (version && !checkIsEncryption(version)) {
+      return url;
+    }
+    if (url.indexOf('?') !== -1) {
+      const encryptedMode = version || '3.0';
+      return `${url.replace(/[^?]+$/g, (data) =>
+        encryptedStrForSearchParams(data, encryptedMode),
+      )}&${securityHeaderKey}=${encryptedMode}`;
+    }
+    return url;
+  };
+
+export const autoSecurityWithUrl: typeof securityType.autoSecurityWithUrl = (
+  url,
+  options,
+) => {
+  let originUrl: string = url;
+  const securityHeaderKey = config.securityHeaderKey as string;
+  const confiMode = config.mode as modeType;
+  const modeInUrl = getSearchObj(url)[securityHeaderKey];
+  const finallyMode =
+    typeof options?.modeRule === 'function'
+      ? options.modeRule(confiMode)
+      : confiMode;
+  // 处理旧模式url
+  if (modeInUrl) {
+    if (checkIsEncryption(modeInUrl)) {
+      if (finallyMode === modeInUrl) {
+        // 如果地址处理前后均为相同加密方式则不需处理
+        return url;
+      }
+      // 否则对url进行解密并移除旧模式参数标识
+      originUrl = removeURLParameters(url, [securityHeaderKey]).replace(
+        /[^?]+$/g,
+        (data) => decryptedStrForSearchParams(data, modeInUrl),
+      );
+    } else if (checkIsSignMode(modeInUrl)) {
+      // 移除旧模式参数标识
+      originUrl = removeURLParameters(url, [
+        config.sign?.valueKeyName as string,
+        securityHeaderKey,
+      ]);
+    }
+  }
+  // 执行加签或加密处理
+  if (checkIsSignMode(finallyMode)) {
+    return createHttpSignWithUrl(originUrl, {}, finallyMode);
+  }
+  if (checkIsEncryption(finallyMode)) {
+    return createEncryptedWithUrl(originUrl, finallyMode as '2.0' | '3.0');
+  }
+  return originUrl;
+};

package/lib/public/src/utils/Security/utils/atob.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-bitwise */
+/* eslint-disable no-plusplus */
+
+const customAtob = (str: string) => {
+  if (typeof atob === 'function') {
+    return atob(str);
+  }
+  const base64 =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  let result = '';
+
+  for (let i = 0; i < str.length; ) {
+    const char1 = base64.indexOf(str.charAt(i++));
+    const char2 = base64.indexOf(str.charAt(i++));
+    const char3 = base64.indexOf(str.charAt(i++));
+    const char4 = base64.indexOf(str.charAt(i++));
+
+    const byte1 = (char1 << 2) | (char2 >> 4);
+    const byte2 = ((char2 & 15) << 4) | (char3 >> 2);
+    const byte3 = ((char3 & 3) << 6) | char4;
+
+    result += String.fromCharCode(byte1);
+
+    if (char3 !== 64) {
+      result += String.fromCharCode(byte2);
+    }
+    if (char4 !== 64) {
+      result += String.fromCharCode(byte3);
+    }
+  }
+  return result;
+};
+
+export default customAtob;

package/lib/public/src/utils/Security/utils/caseInsensitive.ts

@@ -0,0 +1,25 @@
+// 大小写不敏感函数
+
+/**
+ * 获取对象属性值，忽略大小写
+ * @param data 待获取数据的对象数据
+ * @param attr 属性名称
+ * @returns
+ */
+export const getObjectValue = (data: Record<any, any>, attr: string): any => {
+  if (typeof attr === 'undefined' || typeof data === 'undefined')
+    return undefined;
+  // 优先通过attr直接获取数据，如果数据不存在，则进行小写转换再获取
+  let result = data[attr];
+  if (typeof result === 'undefined') {
+    const lowerAttr = attr.toLowerCase();
+    const objectKeys = Object.keys(data);
+    for (let i = 0; i < objectKeys.length; i += 1) {
+      if (objectKeys[i].toLowerCase() === lowerAttr) {
+        result = data[objectKeys[i]];
+        break;
+      }
+    }
+  }
+  return result;
+};

package/lib/public/src/utils/Security/utils/check.ts

@@ -3,7 +3,6 @@ import { MODE } from '../types';
 
 const signModes: string[] = [
   MODE.SIGN,
-  MODE.SIGN_KEY,
   MODE.SIGN_UUID,
   MODE.SIGN_UUID_WITHOUT_SALT,
   MODE.SIGN_WITHOUT_SALT,
@@ -11,28 +10,53 @@ const signModes: string[] = [
 ];
 const signModesWithSalt: string[] = [
   MODE.SIGN,
-  MODE.SIGN_KEY,
   MODE.SIGN_UUID,
   MODE.SIGN_WITH_TIME,
 ];
-const encryptionModes: string[] = [MODE.AES, MODE.DES, MODE.RSA];
+const encryptionModes: string[] = [MODE.AES, MODE.RSA];
 
+/**
+ * 检查安全模式是否为加签
+ * @param mode 模式值
+ * @returns boolean
+ */
 export const checkIsSignMode = (mode: string): boolean => {
   return signModes.includes(mode);
 };
 
+/**
+ * 检查安全模式是否为加签(带盐值)
+ * @param mode 模式值
+ * @returns boolean
+ */
 export const checkIsSignWithSalt = (mode: string): boolean => {
   return signModesWithSalt.includes(mode);
 };
 
+/**
+ * 检查安全模式是否为加密
+ * @param mode 模式值
+ * @returns boolean
+ */
 export const checkIsEncryption = (mode: string): boolean => {
   return encryptionModes.includes(mode);
 };
 
+/**
+ * 检查安全模式是否为合法值
+ * @param mode 模式值
+ * @returns boolean
+ */
 export const checkIsModeValue = (mode: string): boolean => {
   return signModes.includes(mode) || encryptionModes.includes(mode);
 };
 
+/**
+ * 检查当前请求是否需要忽略
+ * @param url 请求地址
+ * @param options 请求参数
+ * @returns boolean
+ */
 export const checkIsUrlIgnore = (
   url: string,
   options?: { headers?: any; body?: any; method?: string },

package/lib/public/src/utils/Security/utils/cookie.ts

@@ -1,70 +1,118 @@
-import capabilities from '../clientCapabilities';
-import message from './message';
-
-const showError = () => message.warn('[lcdp-security]: 当前环境不支持cookie');
-
 const CookieUtil = {
-  get(name: string) {
-    if (!capabilities.cookie) {
-      showError();
-      return null;
-    }
-    const cookieName: string = `${encodeURIComponent(name)}=`;
-    const cookieStart: number = document.cookie.indexOf(cookieName);
-    let cookieValue: string | null = null;
-    let cookieEnd: number;
-
-    if (cookieStart > -1) {
-      cookieEnd = document.cookie.indexOf(';', cookieStart);
-      if (cookieEnd === -1) {
-        cookieEnd = document.cookie.length;
-      }
-      cookieValue = decodeURIComponent(
-        document.cookie.substring(cookieStart + cookieName.length, cookieEnd),
-      );
-    }
-
-    return cookieValue;
+  /**
+   * 获取cookie值
+   * @param key cookie字段名称
+   * @returns cookie值
+   */
+  getItem(key: string) {
+    return (
+      decodeURIComponent(
+        document.cookie.replace(
+          new RegExp(
+            `(?:(?:^|.*;)\\s*${encodeURIComponent(key).replace(
+              /[-.+*]/g,
+              '\\$&',
+            )}\\s*\\=\\s*([^;]*).*$)|^.*$`,
+          ),
+          '$1',
+        ),
+      ) || null
+    );
   },
 
-  set(
-    name: string,
+  /**
+   * 设置cookie值
+   * @param key cookie字段名称
+   * @param value 值
+   * @param end 有效结束事件
+   * @param path 作用域-路径
+   * @param domain 作用域-域名
+   * @param secure 是否只通过 https 协议传输
+   * @returns 设置成功返回true，设置失败返回false
+   */
+  setItem(
+    key: string,
     value: string,
-    expires: Date,
-    path: string,
-    domain: string,
-    secure: boolean,
+    end?: any,
+    path?: string,
+    domain?: string,
+    secure?: boolean,
   ) {
-    if (!capabilities.cookie) {
-      showError();
-      return;
-    }
-    let cookieText = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-
-    if (expires instanceof Date) {
-      cookieText += `; expires=${expires.toUTCString()}`;
-    }
-
-    if (path) {
-      cookieText += `; path=${path}`;
+    if (!key || /^(?:expires|max\-age|path|domain|secure)$/i.test(key)) {
+      return false;
     }
-
-    if (domain) {
-      cookieText += `; domain=${domain}`;
+    let expires = '';
+    if (end) {
+      switch (end.constructor) {
+        case Number:
+          expires =
+            end === Infinity
+              ? '; expires=Fri, 31 Dec 9999 23:59:59 GMT'
+              : `; max-age=${end}`;
+          break;
+        case String:
+          expires = `; expires=${end}`;
+          break;
+        case Date:
+          expires = `; expires=${end.toUTCString()}`;
+          break;
+        default:
+          break;
+      }
     }
+    document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(
+      value,
+    )}${expires}${domain ? `; domain=${domain}` : ''}${
+      path ? `; path=${path}` : ''
+    }${secure ? '; secure' : ''}`;
+    return true;
+  },
 
-    if (secure) {
-      cookieText += '; secure';
+  /**
+   * 删除cookie指定项
+   * @param key cookie字段名称
+   * @param path cookie所在作用域-路径
+   * @param domain cookie所在作用域-域名
+   * @returns 删除成功返回true，删除失败返回false
+   */
+  removeItem(key: string, path?: string, domain?: string) {
+    if (!key || !this.hasItem(key)) {
+      return false;
     }
+    document.cookie = `${encodeURIComponent(
+      key,
+    )}=; expires=Thu, 01 Jan 1970 00:00:00 GMT${
+      domain ? `; domain=${domain}` : ''
+    }${path ? `; path=${path}` : ''}`;
+    return true;
+  },
 
-    document.cookie = cookieText;
+  /**
+   * 是否包含cookie项
+   * @param key cookie字段名称
+   * @returns 存在返回true，不存在返回false
+   */
+  hasItem(key: string) {
+    return new RegExp(
+      `(?:^|;\\s*)${encodeURIComponent(key).replace(/[-.+*]/g, '\\$&')}\\s*\\=`,
+    ).test(document.cookie);
   },
 
-  unset(name: string, path: string, domain: string, secure: boolean) {
-    this.set(name, '', new Date(0), path, domain, secure);
+  /**
+   * 获取cookie里所有字段名称
+   * @returns 字段名称列表
+   */
+  keys() {
+    const aKeys = document.cookie
+      .replace(/((?:^|\s*;)[^\=]+)(?=;|$)|^\s*|\s*(?:\=[^;]*)?(?:\1|$)/g, '')
+      .split(/\s*(?:\=[^;]*)?;\s*/);
+    for (let nIdx = 0; nIdx < aKeys.length; nIdx += 1) {
+      aKeys[nIdx] = decodeURIComponent(aKeys[nIdx]);
+    }
+    return aKeys;
   },
 };
 
-export const getSaltValue = (saltKey: string) => CookieUtil.get(saltKey);
+export const getSaltValue = (saltKey: string) => CookieUtil.getItem(saltKey);
 
 export default CookieUtil;