xzwebx-httpfilter 1.1.5 → 1.2.1

package/HttpFilter.js

@@ -0,0 +1,353 @@
+const Fs = require('fs')
+const Util = require("util")
+const Path = require('path')
+const Crypto = require('crypto')
+
+let ResultCodeMap = {}
+let TipsMap = {}
+let ModuleMap = {}
+let ModuleInterfaceMap = {}
+let FieldMap = {}
+
+function decrypt(sign, key, iv) {
+    let src = ''
+    const cipher = Crypto.createDecipheriv('aes-128-cbc', 'uY4576jBeHGi5ElK', 'Kue76RJhg24WjVet')
+    src += cipher.update(sign, 'hex', 'utf8')
+    src += cipher.final('utf8')
+    return src
+}
+async function response(req, res, next) {
+    let retData = {
+        codeKey: 'SYSTEM_ERR',
+        data: []
+    }
+    retData.codeKey = 'SUCCESS'
+    return res.send(res.Msg(retData))
+}
+function Init(language, resultCodeMap, tipsMap, moduleMap, moduleInterfaceMap, fieldMap) {
+    ResultCodeMap = resultCodeMap
+    TipsMap = tipsMap[language]
+    ModuleMap = moduleMap
+    ModuleInterfaceMap = moduleInterfaceMap
+    FieldMap = fieldMap
+}
+function MSG(params) {
+    let code = ''
+    if (ResultCodeMap[params.codeKey]) {
+        code = ResultCodeMap[params.codeKey].rstCode
+    }
+
+    let msg = ''
+    if (!params.msg) {
+        if (TipsMap[params.codeKey]) {
+            msg = TipsMap[params.codeKey].tips
+        }
+
+    } else {
+        if (typeof params.msg == 'string') {
+            msg = params.msg
+        }
+
+        if (typeof params.msg == 'object' && params.msg.length) {
+            if (TipsMap[params.msg[0]]) {
+                msg = TipsMap[params.msg[0]].tips
+                if (params.msg.length > 1) {
+                    for (let i = 1; i < params.msg.length; i++) {
+                        msg = Util.format(msg, params.msg[i])
+                    }
+                }
+            } else {
+                msg = params.msg[0]
+            }
+        }
+    }
+
+    return {
+        code: code,
+        msg: msg,
+        data: params.data
+    }
+}
+function SetRoutes(app, express, projectPath) {
+    for (let uri in ModuleMap) {
+        let module = ModuleMap[uri]
+        let router = express.Router()
+        let ModuleHandle =  null
+        for (let subUri in ModuleInterfaceMap[module.id]) {
+            for (let method in ModuleInterfaceMap[module.id][subUri]) {
+                let api = ModuleInterfaceMap[module.id][subUri][method]
+                let dirname = Path.join(projectPath, '/impls/' + module.filePath + '.js')
+                if (Fs.existsSync(dirname)) {
+                    ModuleHandle =  require(dirname)
+                }
+
+                if (subUri[0] != '/') {
+                    subUri = '/' + subUri
+                }
+                router[method.toLowerCase()](subUri, ModuleHandle && ModuleHandle[api.moduleFun]? ModuleHandle[api.moduleFun]: response)
+            }
+        }
+        if (ModuleMap[uri].uri[0] != '/') {
+            ModuleMap[uri].uri = '/' + ModuleMap[uri].uri
+        }
+        app.use(ModuleMap[uri].uri, router)
+    }
+}
+function CheckReq(req, res, next) {
+    res.Msg = MSG
+    const baseUrlList = req.url.split('/')
+    const subUri = baseUrlList[baseUrlList.length - 1]
+    let baseUrl = ''
+    for (let idx in baseUrlList) {
+        if (idx == baseUrlList.length - 1) {
+            break
+        }
+        if (baseUrlList[idx]) {
+            baseUrl += '/' + baseUrlList[idx]
+        }
+    }
+
+    const module = ModuleMap[baseUrl]
+    if (!module) {
+        return res.send(res.Msg({codeKey: 'SYSTEM_TIPS', msg: ['ERR_URL']}))
+    }
+
+    if (!ModuleInterfaceMap[module.id] ||
+        !ModuleInterfaceMap[module.id][subUri] ||
+        !ModuleInterfaceMap[module.id][subUri][req.method.toLowerCase()]) {
+        return res.send(res.Msg({codeKey: 'SYSTEM_TIPS', msg: ['ERR_URL']}))
+    }
+
+    req.headers['interfaceInfo'] = ModuleInterfaceMap[module.id][subUri][req.method.toLowerCase()]
+    let reqMsgId = ModuleInterfaceMap[module.id][subUri][req.method.toLowerCase()].reqMsgId
+    if (!reqMsgId) {
+        return next()
+    }
+
+    let retMsgData = cycleCheckParams(FieldMap[reqMsgId], req.body)
+    if (retMsgData) {
+        return res.send(res.Msg({codeKey: 'SYSTEM_TIPS', msg: retMsgData}))
+    }
+
+    return next()
+}
+function cycleCheckParams(msgFieldMap, data) {
+    let retMsgData = null
+    if (!msgFieldMap ||
+        !msgFieldMap['__FieldCfg'] ||
+        !msgFieldMap['__FieldCfg'].ifMust) {
+        return null
+    }
+
+    for (let fieldName in msgFieldMap) {
+        let fCfgItem = msgFieldMap[fieldName]
+        if (fieldName == '__FieldCfg') {
+            if (fCfgItem.ifMust == 'NO' && (data == undefined || data == null || data == '' || (typeof data === 'object' && !data.length && !Object.keys(data).length))) {
+                return null
+            }
+
+            let retMsgData = ''
+            if (fCfgItem.fieldType == 'STR') {
+                retMsgData = IsStringOk(fCfgItem, data)
+            } else if (fCfgItem.fieldType == 'INT') {
+                retMsgData = IsIntOk(fCfgItem, data)
+            } else if (fCfgItem.fieldType == 'OBJ') {
+                retMsgData = IsObjOk(fCfgItem, data)
+            } else if (fCfgItem.fieldType == 'LIST') {
+                retMsgData = IsListOk(fCfgItem, data)
+            }
+            if (retMsgData) {
+                return retMsgData
+            }
+            continue
+        }
+        let fatherFieldType = msgFieldMap['__FieldCfg'].fieldType
+        if (fatherFieldType == 'LIST' || (fatherFieldType == 'OBJ' && msgFieldMap['__FieldCfg'].keyType == 'VOBJ')) {
+            for (let idx in data) {
+                retMsgData = cycleCheckParams(fCfgItem, data[idx])
+                if (retMsgData) {
+                    return retMsgData
+                }
+            }
+        } else {
+            retMsgData = cycleCheckParams(fCfgItem, data[fieldName])
+        }
+
+        if (retMsgData) {
+            return retMsgData
+        }
+    }
+    return null
+}
+function IsStringOk(fCfgItem, paramValue) {
+    if (!paramValue) {
+        return ['NULL_STR_FIELD', fCfgItem.fieldUrl]
+    }
+
+    if (typeof paramValue != 'string') {
+        return ['NOT_STR_VALUE', fCfgItem.fieldUrl]
+    }
+
+    for (let idx in fCfgItem.rules) {
+        let rule = fCfgItem.rules[idx]
+        if (rule.checkType == 'RANGE') {
+            let isPass = false
+            if (typeof rule.exprVal[0] == 'object') {
+                for (let i in rule.exprVal) {
+                    if (paramValue.length >= parseInt(rule.exprVal[i][0]) && paramValue.length <= parseInt(rule.exprVal[i][1])) {
+                        isPass = true
+                        break
+                    }
+                }
+            } else {
+                if (parseInt(rule.exprVal[0]) <= paramValue.length && parseInt(rule.exprVal[1]) >= paramValue.length) {
+                    isPass = true
+                }
+            }
+
+            if (!isPass) {
+                return ['WRONG_STR_RANGE', fCfgItem.fieldUrl, JSON.stringify(rule.exprVal)]
+            }
+        } else if (rule.checkType == 'ENU') {
+            if (rule.isCaseSensitive == 1) {
+                if (rule.exprVal && rule.exprVal.length && !rule.exprVal.includes(paramValue)) {
+                    return ['WRONG_ENU_VALUE', fCfgItem.fieldUrl, rule.exprVal]
+                }
+            } else {
+                let isPass = false
+                for (let k in rule.exprVal) {
+                    if (rule.exprVal[k].toUpperCase() == paramValue.toUpperCase()) {
+                        isPass = true
+                        break
+                    }
+                }
+                if (!isPass) {
+                    return ['WRONG_ENU_VALUE', fCfgItem.fieldUrl, rule.exprVal]
+                }
+            }
+        } else if (rule.checkType == 'REGEX') {
+            let isPass = false
+            let exprVal = rule.exprVal + ''
+            for (let i in rule.exprVal) {
+                let reg = eval(rule.exprVal[i])
+                let found = reg.test(paramValue)
+                if (rule.matchType == 'AND') {
+                    if (!found) {
+                        exprVal = rule.exprVal[i] + ''
+                        break
+                    }
+                } else {
+                    if (found) {
+                        isPass = true
+                        break
+                    }
+                }
+            }
+            if (!isPass) {
+                return ['WRONG_REGEX_VALUE', fCfgItem.fieldUrl, exprVal]
+            }
+        }
+    }
+
+    return null
+}
+function IsIntOk(fCfgItem, paramValue) {
+    if (paramValue == undefined) {
+        return ['NULL_INT_FIELD', fCfgItem.fieldUrl]
+    }
+
+    if (typeof paramValue != 'number') {
+        return ['NOT_INT_VALUE', fCfgItem.fieldUrl]
+    }
+
+    for (let idx in fCfgItem.rules) {
+        let rule = fCfgItem.rules[idx]
+        if (rule.checkType == 'RANGE') {
+            let isPass = false
+            if (typeof rule.exprVal[0] == 'object') {
+                for (let i in rule.exprVal) {
+                    if (paramValue >= +rule.exprVal[i][0] && paramValue <= +rule.exprVal[i][1]) {
+                        isPass = true
+                        break
+                    }
+                }
+            } else {
+                if (+rule.exprVal[0] <= paramValue && +rule.exprVal[1] >= paramValue) {
+                    isPass = true
+                }
+            }
+
+            if (!isPass) {
+                return ['WRONG_INT_RANGE', fCfgItem.fieldUrl, JSON.stringify(rule.exprVal)]
+            }
+        } else if (rule.checkType == 'ENU') {
+            if (rule.exprVal && rule.exprVal.length && !rule.exprVal.includes(paramValue)) {
+                return ['WRONG_ENU_VALUE', fCfgItem.fieldUrl, rule.exprVal]
+            }
+        } else if (rule.checkType == 'REGEX') {
+            let isPass = false
+            let exprVal = rule.exprVal + ''
+            for (let i in rule.exprVal) {
+                let reg = eval(rule.exprVal[i])
+                let found = reg.test(paramValue + '')
+                if (rule.matchType == 'AND') {
+                    if (!found) {
+                        exprVal = rule.exprVal[i] + ''
+                        break
+                    }
+                } else {
+                    if (found) {
+                        isPass = true
+                        break
+                    }
+                }
+            }
+            if (!isPass) {
+                return ['WRONG_REGEX_VALUE', fCfgItem.fieldUrl, exprVal]
+            }
+        }
+    }
+
+    return null
+}
+function IsObjOk(fCfgItem, paramValue) {
+    if (!paramValue) {
+        return ['NULL_FIELD', fCfgItem.fieldUrl]
+    }
+
+    if (paramValue.constructor != Object) {
+        return ['WRONG_OBJ_VALUE', fCfgItem.fieldUrl]
+    }
+
+    if (!Object.keys(paramValue).length) {
+        return ['NULL_VALUE', fCfgItem.fieldUrl]
+    }
+
+    return null
+}
+function IsListOk(fCfgItem, paramValue) {
+    if (!paramValue) {
+        return ['NULL_FIELD', fCfgItem.fieldUrl]
+    }
+
+    if (paramValue.constructor != Array) {
+        return ['WRONG_LIST_VALUE', fCfgItem.fieldUrl]
+    }
+
+    if (!paramValue.length) {
+        return ['NULL_VALUE', fCfgItem.fieldUrl]
+    }
+
+    return null
+}
+
+function SetMsg(req, res, next) {
+    res.Msg = MSG
+    return next()
+}
+module.exports = {
+    Init: Init,
+    SetRoutes: SetRoutes,
+    CheckReq: CheckReq,
+    SetMsg: SetMsg,
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "xzwebx-httpfilter",
-  "version": "1.1.5",
-  "main": "xzwebx-httpfilter.js",
+  "version": "1.2.1",
+  "main": "HttpFilter.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/hook-require.js

@@ -1,16 +0,0 @@
-const _module = require('module')
-const path = require('path')
-const makeRequire = require('./make-require')
-const { loadBytecode } = require('./loader')
-
-_module._extensions['.bytecode'] = function (module, filename) {
-    const script = loadBytecode(filename, false);
-    const wrapperFn = script.runInThisContext({
-        filename: filename,
-        displayErrors: true,
-        lineOffset: 0,
-        columnOffset: 0,
-    })
-    const require = makeRequire(module)
-    wrapperFn.bind(module.exports)(module.exports, require, module, filename, path.dirname(filename))
-}

package/loader.js

@@ -1,71 +0,0 @@
-const fs = require('fs')
-const vm = require('vm')
-const v8 = require('v8')
-v8.setFlagsFromString('--no-flush-bytecode')
-
-const HeaderOffsetMap = {
-    'magic': 0,
-    'version_hash': 4,
-    'source_hash': 8,
-    'flag_hash': 12
-};
-
-let _flag_buf
-
-function getFlagBuf() {
-    if (!_flag_buf) {
-        const script = new vm.Script("")
-        _flag_buf = getHeader(script.createCachedData(), 'flag_hash')
-    }
-    return _flag_buf
-}
-
-function getHeader(buffer, type) {
-    const offset = HeaderOffsetMap[type]
-    return buffer.slice(offset, offset + 4)
-}
-
-function setHeader(buffer, type, vBuffer) {
-    vBuffer.copy(buffer, HeaderOffsetMap[type])
-}
-
-function buf2num(buf) {
-    let ret = 0
-    ret |= buf[3] << 24
-    ret |= buf[2] << 16
-    ret |= buf[1] << 8
-    ret |= buf[0]
-
-    return ret
-}
-
-function loadBytecode(filePath) {
-    const bytecode = fs.readFileSync(filePath, null)
-
-    setHeader(bytecode, 'flag_hash', getFlagBuf())
-
-    const sourceHash = buf2num(getHeader(bytecode, 'source_hash'))
-    const script = new vm.Script(' '.repeat(sourceHash), {
-        filename: filePath,
-        cachedData: bytecode,
-        lineOffset: 0,
-        displayErrors: true
-    });
-
-    if (script.cachedDataRejected) {
-        throw new Error('something is wrong')
-    }
-    return script
-}
-
-if (process.mainModule && process.mainModule.filename === __filename) {
-    const scirpt = loadBytecode(process.argv[2])
-    scirpt.runInThisContext({
-        filename: process.argv[2],
-        displayErrors: true,
-        lineOffset: 0,
-        columnOffset: 0,
-    });
-}
-
-module.exports.loadBytecode = loadBytecode

package/make-require.js

@@ -1,32 +0,0 @@
-function validateString(value, name) {
-    if (typeof value !== 'string') {
-        throw new Error(`${name} is not string`)
-    }
-}
-
-function makeRequireFunction(mod) {
-    // see node.js lib/internal/modules/cjs/helpers.js
-    const Module = mod.constructor
-
-    const require = function require(path) {
-        return mod.require(path)
-    };
-
-    require.resolve = function resolve(request, options) {
-        validateString(request, 'request')
-        return Module._resolveFilename(request, mod, false, options)
-    }
-
-    require.resolve.paths = function paths(request) {
-        validateString(request, 'request')
-        return Module._resolveLookupPaths(request, mod)
-    };
-
-    require.main = process.mainModule
-    require.extensions = Module._extensions
-    require.cache = Module._cache
-
-    return require
-}
-
-module.exports = makeRequireFunction

package/xzwebx-httpfilter.js

@@ -1,20 +0,0 @@
-require('./hook-require')
-const HttpFilter = require('./HttpFilter.bytecode')
-
-const H = {}
-H.Init = function(language, data1, data2, data3, data4, data5) {
-    HttpFilter.Init(language, data1, data2, data3, data4, data5)
-}
-
-H.SetRoutes = function (app, express, projectPath) {
-    HttpFilter.SetRoutes(app, express, projectPath)
-}
-
-H.CheckReq = function (req, res, next) {
-    HttpFilter.CheckReq(req, res, next)
-}
-
-H.SetMsg = function (req, res, next) {
-    HttpFilter.SetMsg(req, res, next)
-}
-module.exports = H