From 5fedd25cc65a1f90340b7de61b342112a1d7a0ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Wed, 6 May 2026 17:41:57 +0800 Subject: [PATCH 1/6] sync: update core engine codebase Full sync of latest engine code: - Add PHP analyzer, parser patch, checkers and benchmark tests - Extend Python support with httpserver entrypoints and Django/Tornado/eval coverage - Refine taint propagation, sanitizer, sink/source utilities and rules-basic-handler - Improve callchain checkers (JS/Python/PHP) and full-callgraph file-entrypoint logic - Update analyzer/initializer/exception handler and shared utilities (precondition, memorial, call-info-util) - Refresh checker/tag-propagation/example rule configs and build scripts - Sync benchmark expectations and add new tests (rules-basic-handler, trace-accuracy) --- .gitignore | 7 + .npmrc | 1 + build.sh | 9 +- package.json | 20 +- resource/checker/checker-config.json | 17 + resource/checker/checker-pack-config.json | 18 + .../example-rule-config/rule_config_php.json | 842 +++++++ .../lib-func-tag-propagation-rule.json | 15 + ruleconfig_test.json | 68 + scripts/patch-uast-parser-php.js | 116 + src/checker/callchain/callchain-checker.ts | 5 +- .../callchain/js/js-callchain-checker.ts | 44 +- .../callchain/php/php-callchain-checker.ts | 222 ++ .../python/python-callchain-checker.ts | 7 +- src/checker/common/checker.ts | 3 +- .../common/full-callgraph-file-entrypoint.ts | 45 +- .../output/callchain-output-strategy.ts | 4 +- .../common/output/taint-output-strategy.ts | 136 +- .../common/ql-uast-convert/converter.ts | 3 +- src/checker/common/rules-basic-handler.ts | 116 +- src/checker/common/value/precondition.ts | 46 + src/checker/sanitizer/sanitizer-checker.ts | 153 +- src/checker/sdk/get-file-ast-checker.ts | 4 +- .../taint/common-kit/call-info-util.ts | 23 + src/checker/taint/common-kit/sink-util.ts | 17 + src/checker/taint/common-kit/source-util.ts | 34 +- .../taint/common-kit/taint-finding-util.ts | 4 +- .../go/beego-entrypoint-collect-checker.ts | 6 +- .../taint/go/gin-default-taint-checker.ts | 6 +- src/checker/taint/go/gin-taint-checker.ts | 30 +- .../taint/go/go-default-taint-checker.ts | 12 +- .../taint/java/java-taint-abstract-checker.ts | 66 +- src/checker/taint/js/egg-taint-checker.ts | 34 +- .../taint/js/express/express-taint-checker.ts | 34 +- src/checker/taint/js/js-taint-checker.ts | 34 +- .../taint/php/php-default-taint-checker.ts | 352 +++ .../taint/python/django-taint-checker.ts | 432 +++- .../taint/python/httpserver-taint-checker.ts | 168 ++ .../python/python-taint-abstract-checker.ts | 25 +- .../taint/python/python-taint-checker.ts | 67 +- .../taint/python/tornado-taint-checker.ts | 2 +- src/checker/taint/taint-checker.ts | 384 ++- src/checker/taint/test-taint-checker.ts | 8 +- src/config.ts | 4 +- src/engine/analyzer/common/analyzer.ts | 295 ++- src/engine/analyzer/common/checker-manager.ts | 4 + src/engine/analyzer/common/common-types.ts | 2 +- src/engine/analyzer/common/entrypoint.ts | 12 + .../analyzer/common/exception-handler.ts | 30 + src/engine/analyzer/common/initializer.ts | 4 + src/engine/analyzer/common/memSpace.ts | 116 +- src/engine/analyzer/common/memStateBVT.ts | 66 +- src/engine/analyzer/common/sarif.ts | 96 +- src/engine/analyzer/common/scope.ts | 13 +- src/engine/analyzer/common/source-line.ts | 12 +- .../analyzer/common/value/ast-binding.ts | 20 +- src/engine/analyzer/common/value/object.ts | 2 + src/engine/analyzer/common/value/union.ts | 3 +- src/engine/analyzer/common/value/unit.ts | 32 +- src/engine/analyzer/common/value/value-ref.ts | 15 +- .../analyzer/golang/common/go-analyzer.ts | 631 ++++- .../gin-default-entrypoint.ts | 83 +- .../builtins/executorservice-builtins.ts | 13 +- .../analyzer/java/common/java-analyzer.ts | 95 +- .../analyzer/java/spring/spring-analyzer.ts | 223 ++ .../analyzer/javascript/common/js-analyzer.ts | 10 +- .../analyzer/javascript/egg/egg-analyzer.ts | 41 +- .../javascript/egg/egg-initializer.ts | 48 + .../egg/entrypoint-collector/egg-http.ts | 6 +- .../php/common/builtins/php-builtins.ts | 81 + .../analyzer/php/common/php-analyzer.ts | 2141 +++++++++++++++++ .../haodf-databucket-entrypoint.ts | 161 ++ .../haodf-mvc-controller-entrypoint.ts | 119 + .../soa-service-entrypoint.ts | 140 ++ .../sparta-default-entrypoint.ts | 157 ++ .../python/common/builtins/python-builtins.ts | 100 + .../entrypoint-collector/python-entrypoint.ts | 19 +- .../analyzer/python/common/python-analyzer.ts | 220 +- .../fastapi-entrypoint.ts | 4 +- .../flask-default-entrypoint.ts | 3 + .../httpserver-entrypoint.ts | 253 ++ .../inference-default-entrypoint.ts | 6 + .../mcp-default-entrypoint.ts | 3 + src/engine/parser/golang/go-ast-builder.ts | 14 +- src/engine/parser/java/java-ast-builder.ts | 7 +- src/engine/parser/parser-core.ts | 87 +- src/engine/parser/parser-worker.ts | 13 + src/engine/parser/parser.ts | 24 + src/engine/parser/php/php-ast-builder.ts | 51 + .../parser/python/python-ast-builder.ts | 15 +- src/interface/starter.ts | 103 +- src/main.ts | 7 - .../common/type-related-info-resolver.ts | 2 +- .../go/go-type-related-info-resolver.ts | 98 +- src/util/ast-util.ts | 7 +- src/util/clone-util.ts | 16 +- src/util/constant.ts | 2 +- src/util/error-code.ts | 13 +- src/util/file-util.ts | 9 +- src/util/framework-util.ts | 15 +- src/util/loader.ts | 7 +- src/util/memorial.ts | 145 ++ src/util/performance-tracker.ts | 2 +- src/util/qid-unify-util.ts | 8 + .../callchain/expect/callchain-go-expect.json | 18 +- .../expect/callchain-java-expect.json | 4 +- .../callchain/expect/callchain-js-expect.json | 213 +- .../expect/callchain-python-expect.json | 8 +- test/callchain/test-all-callchain.ts | 47 +- test/go/expect/gobenchmark-expect.json | 2 +- test/java/expect/sast-java-expect.result | 236 +- test/java/test-java-benchmark.ts | 39 +- test/java/test-java-real-project.ts | 35 +- .../expect/chairbenchmark-expect.result | 1119 +++++++++ .../javascript/expect/jsbenchmark-expect.json | 2 +- test/javascript/prepare-js-benchmark.ts | 8 + test/javascript/test-egg-benchmark.ts | 203 ++ test/php/checker-cases/test_callchain.php | 14 + test/php/checker-cases/test_cmdi.php | 5 + test/php/checker-cases/test_sqli.php | 6 + test/php/checker-cases/test_xss.php | 5 + test/php/expect/phpbenchmark-expect.json | 1 + test/php/generate-expect.ts | 152 ++ test/php/prepare-php-benchmark.ts | 132 + test/php/rule_config.json | 158 ++ test/php/test-php-benchmark.ts | 379 +++ test/php/test-php-checker.ts | 193 ++ .../expect/pythonbenchmark-expect.result | 839 +++---- test/python/test-python-benchmark.ts | 31 + test/rules-basic-handler/test-match-field.ts | 240 ++ .../test-sink-util-new-expr.ts | 142 ++ test/trace-accuracy.ts | 200 ++ 132 files changed, 12663 insertions(+), 1335 deletions(-) create mode 100644 .npmrc create mode 100644 resource/example-rule-config/rule_config_php.json create mode 100644 ruleconfig_test.json create mode 100644 scripts/patch-uast-parser-php.js create mode 100644 src/checker/callchain/php/php-callchain-checker.ts create mode 100644 src/checker/common/value/precondition.ts create mode 100644 src/checker/taint/common-kit/call-info-util.ts create mode 100644 src/checker/taint/php/php-default-taint-checker.ts create mode 100644 src/checker/taint/python/httpserver-taint-checker.ts create mode 100644 src/engine/analyzer/php/common/builtins/php-builtins.ts create mode 100644 src/engine/analyzer/php/common/php-analyzer.ts create mode 100644 src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts create mode 100644 src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts create mode 100644 src/engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint.ts create mode 100644 src/engine/analyzer/php/sparta/entrypoint-collector/sparta-default-entrypoint.ts create mode 100644 src/engine/analyzer/python/common/builtins/python-builtins.ts create mode 100644 src/engine/analyzer/python/httpserver/entrypoint-collector/httpserver-entrypoint.ts create mode 100644 src/engine/parser/php/php-ast-builder.ts create mode 100644 src/util/memorial.ts create mode 100644 test/javascript/expect/chairbenchmark-expect.result create mode 100644 test/javascript/test-egg-benchmark.ts create mode 100644 test/php/checker-cases/test_callchain.php create mode 100644 test/php/checker-cases/test_cmdi.php create mode 100644 test/php/checker-cases/test_sqli.php create mode 100644 test/php/checker-cases/test_xss.php create mode 100644 test/php/expect/phpbenchmark-expect.json create mode 100644 test/php/generate-expect.ts create mode 100644 test/php/prepare-php-benchmark.ts create mode 100644 test/php/rule_config.json create mode 100644 test/php/test-php-benchmark.ts create mode 100644 test/php/test-php-checker.ts create mode 100644 test/rules-basic-handler/test-match-field.ts create mode 100644 test/rules-basic-handler/test-sink-util-new-expr.ts create mode 100644 test/trace-accuracy.ts diff --git a/.gitignore b/.gitignore index 8d27ac29..06c796a0 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,7 @@ test/javascript/benchmarks test/go/benchmarks test/python/benchmarks test/java/benchmarks +test/php/benchmarks CNVD-*/ TODO.md *.dot @@ -50,4 +51,10 @@ src/uast deps-runtime/ .cursorrules test/javascript/test-report +test/trace-accuracy-reports +test/java/report +test/python/report +test/javascript/report +test/php/report deps +node_modules diff --git a/.npmrc b/.npmrc new file mode 100644 index 00000000..7549542d --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ +registry=https://registry.npmmirror.com diff --git a/build.sh b/build.sh index 242d4725..3e0a3de1 100755 --- a/build.sh +++ b/build.sh @@ -41,6 +41,13 @@ if ! npm install --package-lock=false > /dev/null; then fi success "依赖安装完成" +# 步骤 1.5: patch @ant-yasa/uast-parser-php 规避 pkg 对 require.resolve('*.wasm') 的 UTF-8 mangle +info "步骤 1.5/8: patch uast-parser-php (node scripts/patch-uast-parser-php.js)" +if ! node scripts/patch-uast-parser-php.js; then + alert "uast-parser-php patch 失败" +fi +success "uast-parser-php patch 完成" + # 步骤 2: 类型检查 info "步骤 2/8: 类型检查 (npx tsc --noEmit)" # 只重定向 stdout，保留 stderr 以便显示错误信息 @@ -110,7 +117,7 @@ EOF info "步骤 7/8: 打包二进制 (npx pkg)" # 只重定向 stdout，保留 stderr 以便显示错误信息 set +e -npx pkg . --options max-old-space-size=12288 > /dev/null +npx pkg . --options max-old-space-size=11264 > /dev/null PKG_EXIT_CODE=$? set -e if [ $PKG_EXIT_CODE -ne 0 ]; then diff --git a/package.json b/package.json index e629d26a..ac1beb8a 100644 --- a/package.json +++ b/package.json @@ -5,8 +5,9 @@ "main": "./dist/main.js", "bin": "./dist/main.js", "dependencies": { - "@ant-yasa/uast-parser-java-js": "^0.2.9", - "@ant-yasa/uast-spec": "^0.2.9", + "@ant-yasa/uast-parser-java-js": "^0.2.12", + "@ant-yasa/uast-parser-php": "^0.2.12", + "@ant-yasa/uast-spec": "^0.2.12", "@babel/core": "^7.14.6", "@babel/parser": "^7.16.4", "@babel/plugin-proposal-decorators": "^7.14.5", @@ -84,16 +85,23 @@ }, "scripts": { "test-js": "npx mocha --require tsx/cjs test/javascript/test-js-benchmark.ts", + "test-egg": "npx mocha --require tsx/cjs test/javascript/test-egg-benchmark.ts", "test-java": "npx mocha --require tsx/cjs test/java/test-java-benchmark.ts", "test-go": "npx mocha --require tsx/cjs test/go/test-go-benchmark.ts", "test-python": "npx mocha --require tsx/cjs test/python/test-python-benchmark.ts", "test-callchain": "npx mocha --require tsx/cjs test/callchain/test-callchain-benchmark.ts", "test-callargs": "npx mocha --require tsx/cjs test/callargs/test-callargs.ts", - "test-all": "npm run test-callargs && npm run test-js && npm run test-java && npm run test-go && npm run test-python && npm run test-callchain", + "test-match-field": "npx mocha --require tsx/cjs test/rules-basic-handler/test-match-field.ts", + "test-sink-util-new-expr": "npx mocha --require tsx/cjs test/rules-basic-handler/test-sink-util-new-expr.ts", + "test-php-checker": "npx mocha --require tsx/cjs test/php/test-php-checker.ts", + "test-php": "npx mocha --require tsx/cjs test/php/test-php-benchmark.ts", + "test-all": "npm run test-callargs && npm run test-match-field && npm run test-sink-util-new-expr && npm run test-js && npm run test-egg && npm run test-java && npm run test-go && npm run test-python && npm run test-callchain && npm run test-php", "build": "bash build.sh", "lint": "eslint .", "lint:duplicates": "jscpd .", - "lint:fix": "eslint --fix ." + "lint:fix": "eslint --fix .", + "trace-accuracy": "npx tsx test/trace-accuracy.ts", + "trace-accuracy-all": "NODE_OPTIONS='--max-old-space-size=13312' npx tsx test/trace-accuracy-all.ts" }, "install": "npm install", "files": [ @@ -173,7 +181,9 @@ "dist/**/*", "resource/**/*", "deps/uast4go/uast4go", - "deps/uast4py/uast4py" + "deps/uast4py/uast4py", + "node_modules/tree-sitter-php/*.wasm", + "node_modules/web-tree-sitter/web-tree-sitter.wasm" ], "targets": [ "node18-macos-arm64", diff --git a/resource/checker/checker-config.json b/resource/checker/checker-config.json index 2638516a..13cd5003 100644 --- a/resource/checker/checker-config.json +++ b/resource/checker/checker-config.json @@ -140,11 +140,22 @@ "checkerPath": "checker/taint/python/tornado-taint-checker.ts", "description": "python Tornado框架 entrypoint采集以及框架source添加" }, + { + "checkerId": "taint_flow_python_httpserver_input", + "checkerPath": "checker/taint/python/httpserver-taint-checker.ts", + "description": "python http.server框架 entrypoint采集以及框架source添加" + }, { "checkerId": "taint_flow_python_script_input", "checkerPath": "checker/taint/python/script-taint-checker.ts", "description": "Python脚本命令行参数source添加，支持argparse/sys.argv/input/os.environ/getopt等" }, + { + "checkerId": "taint_flow_php_input", + "checkerPath": "checker/taint/php/php-default-taint-checker.ts", + "description": "PHP污点分析checker，会使用CallGraph边界制作entrypoint", + "demoRuleConfigPath": "resource/example-rule-config/rule_config_php.json" + }, { "checkerId": "taint_flow_test", "checkerPath": "checker/taint/test-taint-checker.ts", @@ -194,5 +205,11 @@ "checkerPath": "checker/callchain/python/python-callchain-checker.ts", "description": "Python callchain checker，只检测sink匹配并输出调用链路", "demoRuleConfigPath": "resource/example-rule-config/rule_config_python.json" + }, + { + "checkerId": "callchain_php", + "checkerPath": "checker/callchain/php/php-callchain-checker.ts", + "description": "PHP callchain checker，只检测sink匹配并输出调用链路", + "demoRuleConfigPath": "resource/example-rule-config/rule_config_php.json" } ] diff --git a/resource/checker/checker-pack-config.json b/resource/checker/checker-pack-config.json index 21387ea4..7022af18 100644 --- a/resource/checker/checker-pack-config.json +++ b/resource/checker/checker-pack-config.json @@ -88,6 +88,7 @@ "taint_flow_python_input", "taint_flow_python_django_input", "taint_flow_python_tornado_input", + "taint_flow_python_httpserver_input", "callgraph", "sanitizer" ], @@ -99,6 +100,7 @@ "taint_flow_python_input_inner", "taint_flow_python_django_input", "taint_flow_python_tornado_input", + "taint_flow_python_httpserver_input", "callgraph", "sanitizer" ], @@ -153,5 +155,21 @@ "callchain_python" ], "description": "Python callchain checker - 只检测sink匹配" + }, + { + "checkerPackId": "taint-flow-php-default", + "checkerIds": [ + "taint_flow_php_input", + "callgraph", + "sanitizer" + ], + "description": "PHP污点追踪-对外默认使用的规则包" + }, + { + "checkerPackId": "callchain-php", + "checkerIds": [ + "callchain_php" + ], + "description": "PHP callchain checker - 只检测sink匹配" } ] diff --git a/resource/example-rule-config/rule_config_php.json b/resource/example-rule-config/rule_config_php.json new file mode 100644 index 00000000..dfa98746 --- /dev/null +++ b/resource/example-rule-config/rule_config_php.json @@ -0,0 +1,842 @@ +[ + { + "checkerIds": [ + "taint_flow_php_input" + ], + "sources": { + "TaintSource": [ + { + "className": "", + "path": "_GET", + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "className": "", + "path": "_POST", + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "className": "", + "path": "_REQUEST", + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "className": "", + "path": "_COOKIE", + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "className": "", + "path": "_SERVER", + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "className": "", + "path": "_FILES", + "scopeFile": "all", + "scopeFunc": "all" + } + ], + "FuncCallReturnValueTaintSource": [ + { + "fsig": "readline", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getRequest", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getPost", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getQuery", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getCookie", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getHeader", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getEnv", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getUnSafeData", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getAllRequest", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "getAllGetAndPost", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "input", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + }, + { + "fsig": "param", + "calleeType": "*", + "values": [ + "0" + ], + "scopeFile": "all", + "scopeFunc": "all" + } + ] + }, + "sinks": { + "FuncCallTaintSink": [ + { + "args": [ + "1" + ], + "attribute": "PhpSqlInjection", + "fsig": "mysqli_query" + }, + { + "args": [ + "1" + ], + "attribute": "PhpSqlInjection", + "fsig": "mysqli_multi_query" + }, + { + "args": [ + "1" + ], + "attribute": "PhpSqlInjection", + "fsig": "mysqli_prepare" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "mysqli", + "fsig": "query" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "mysqli", + "fsig": "multi_query" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "mysqli", + "fsig": "prepare" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "PDO", + "fsig": "query" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "PDO", + "fsig": "exec" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "PDO", + "fsig": "prepare" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "fsig": "mysql_query" + }, + { + "args": [ + "1" + ], + "attribute": "PhpSqlInjection", + "fsig": "pg_query" + }, + { + "args": [ + "1" + ], + "attribute": "PhpSqlInjection", + "fsig": "pg_query_params" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "exec" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "system" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "passthru" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "shell_exec" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "popen" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "proc_open" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCommandInjection", + "fsig": "pcntl_exec" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "eval" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "assert" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "preg_replace" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "create_function" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "call_user_func" + }, + { + "args": [ + "*" + ], + "attribute": "PhpCodeInjection", + "fsig": "call_user_func_array" + }, + { + "args": [ + "*" + ], + "attribute": "PhpDeserialization", + "fsig": "unserialize" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXSS", + "fsig": "echo" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXSS", + "fsig": "print" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXSS", + "fsig": "printf" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXSS", + "fsig": "vprintf" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "file_get_contents" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "file_put_contents" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "fopen" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "readfile" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "include" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "include_once" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "require" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "require_once" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "copy" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "rename" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "unlink" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "mkdir" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "rmdir" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "move_uploaded_file" + }, + { + "args": [ + "2" + ], + "attribute": "PhpSSRF", + "fsig": "curl_setopt" + }, + { + "args": [ + "*" + ], + "attribute": "PhpSSRF", + "fsig": "curl_init" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSSRF", + "fsig": "file_get_contents" + }, + { + "args": [ + "*" + ], + "attribute": "PhpSSRF", + "fsig": "fsockopen" + }, + { + "args": [ + "*" + ], + "attribute": "PhpHeaderInjection", + "fsig": "header" + }, + { + "args": [ + "*" + ], + "attribute": "PhpHeaderInjection", + "fsig": "setcookie" + }, + { + "args": [ + "*" + ], + "attribute": "PhpLDAPInjection", + "fsig": "ldap_search" + }, + { + "args": [ + "*" + ], + "attribute": "PhpLDAPInjection", + "fsig": "ldap_list" + }, + { + "args": [ + "*" + ], + "attribute": "PhpLDAPInjection", + "fsig": "ldap_read" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "fsig": "simplexml_load_string" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "fsig": "simplexml_load_file" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "DOMDocument", + "fsig": "loadXML" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "DOMDocument", + "fsig": "load" + }, + { + "args": [ + "*" + ], + "attribute": "PhpLogInjection", + "fsig": "error_log" + }, + { + "args": [ + "*" + ], + "attribute": "PhpLogInjection", + "fsig": "syslog" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "query" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "queryValue" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "queryColumn" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "multi_query" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "prepare" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "*", + "fsig": "exec" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "SimpleXMLElement", + "fsig": "loadXML" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "SimpleXMLElement", + "fsig": "load" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "SimpleXMLIterator", + "fsig": "load" + }, + { + "args": [ + "*" + ], + "attribute": "PhpXXE", + "calleeType": "XMLReader", + "fsig": "open" + }, + { + "args": [ + "0" + ], + "attribute": "PhpSqlInjection", + "calleeType": "DbExecuter", + "fsig": "execute" + }, + { + "args": [ + "0" + ], + "attribute": "PhpPathTraversal", + "fsig": "tempnam" + }, + { + "args": [ + "*" + ], + "attribute": "PhpPathTraversal", + "fsig": "tmpfile" + }, + { + "args": [ + "1" + ], + "attribute": "PhpCSVInjection", + "fsig": "fputcsv" + }, + { + "args": [ + "1" + ], + "attribute": "PhpPathTraversal", + "fsig": "fwrite" + }, + { + "args": [ + "*" + ], + "attribute": "PhpHeaderInjection", + "fsig": "setrawcookie" + }, + { + "args": [ + "0" + ], + "attribute": "PhpHeaderInjection", + "fsig": "http_response_code" + }, + { + "args": [ + "0" + ], + "attribute": "PhpHeaderInjection", + "fsig": "header_remove" + }, + { + "args": [ + "0" + ], + "attribute": "PhpPathTraversal", + "fsig": "chmod" + }, + { + "args": [ + "0" + ], + "attribute": "PhpPathTraversal", + "fsig": "chown" + } + ] + }, + "sanitizers": { + "FuncCallSanitizer": [ + { + "fsig": "htmlspecialchars", + "sanitizerType": "PhpXSS" + }, + { + "fsig": "htmlentities", + "sanitizerType": "PhpXSS" + }, + { + "fsig": "strip_tags", + "sanitizerType": "PhpXSS" + }, + { + "fsig": "mysqli_real_escape_string", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "real_escape_string", + "calleeType": "mysqli", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "quote", + "calleeType": "PDO", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "addslashes", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "pg_escape_string", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "pg_escape_literal", + "sanitizerType": "PhpSqlInjection" + }, + { + "fsig": "intval", + "sanitizerType": "ALL" + }, + { + "fsig": "floatval", + "sanitizerType": "ALL" + }, + { + "fsig": "is_numeric", + "sanitizerType": "ALL" + }, + { + "fsig": "ctype_digit", + "sanitizerType": "ALL" + }, + { + "fsig": "ctype_alpha", + "sanitizerType": "ALL" + }, + { + "fsig": "ctype_alnum", + "sanitizerType": "ALL" + }, + { + "fsig": "escapeshellarg", + "sanitizerType": "PhpCommandInjection" + }, + { + "fsig": "escapeshellcmd", + "sanitizerType": "PhpCommandInjection" + }, + { + "fsig": "urlencode", + "sanitizerType": "PhpSSRF" + }, + { + "fsig": "rawurlencode", + "sanitizerType": "PhpSSRF" + }, + { + "fsig": "basename", + "sanitizerType": "PhpPathTraversal" + }, + { + "fsig": "realpath", + "sanitizerType": "PhpPathTraversal" + }, + { + "fsig": "filter_var", + "sanitizerType": "ALL" + }, + { + "fsig": "filter_input", + "sanitizerType": "ALL" + }, + { + "fsig": "preg_replace", + "sanitizerType": "ALL" + }, + { + "fsig": "dirname", + "sanitizerType": "PhpPathTraversal" + }, + { + "fsig": "libxml_disable_entity_loader", + "sanitizerType": "PhpXXE" + } + ] + } + } +] diff --git a/resource/tag-propagation/lib-func-tag-propagation-rule.json b/resource/tag-propagation/lib-func-tag-propagation-rule.json index e8a44f2b..02da21ac 100644 --- a/resource/tag-propagation/lib-func-tag-propagation-rule.json +++ b/resource/tag-propagation/lib-func-tag-propagation-rule.json @@ -59,6 +59,21 @@ "type": "ARG", "index": 0 } + }, + { + "func": { + "calleeType": "*", + "fsig": "write", + "argNum": 1 + }, + "source": { + "type": "ARG", + "index": 0 + }, + "target": { + "type": "THIS", + "propagateToOwner": true + } } ] } diff --git a/ruleconfig_test.json b/ruleconfig_test.json new file mode 100644 index 00000000..6aef1991 --- /dev/null +++ b/ruleconfig_test.json @@ -0,0 +1,68 @@ +[ + { + "checkerIds": [ + "taint_flow_egg_input", + "taint_flow_js_input", + "taint_flow_express_input" + ], + "entrypoints": [ + { + "attribute": "HTTP", + "filePath": "/src/http/agent.ts", + "functionName": "agent" + } + ], + "sources": { + "TaintSource": [ + { + "path": "data", + "scopeFile": "/src/http/agent.ts", + "scopeFunc": "agent" + } + ] + }, + "sinks": { + "FuncCallTaintSink": [ + { + "args": [ + "*" + ], + "attribute": "NodejsLevelAuthority", + "fsig": "agent.streamChat", + "sanitizerIds": [ + "SANITIZER_1" + ] + } + ] + }, + "sanitizers": [ + { + "id": "SANITIZER_1", + "sanitizerType": "FunctionCallSanitizer", + "sanitizerScenario": "SANITIZER.VALIDATE_BY_FUNCTIONCALL", + "fsig": "agentWhiteList.includes", + "args": [ + "0" + ] + }, + { + "id": "SANITIZER_2", + "sanitizerType": "FunctionCallSanitizer", + "sanitizerScenario": "SANITIZER.VALIDATE_BY_FUNCTIONCALL", + "fsig": "agentWhiteList.includes", + "args": [ + "0" + ] + }, + { + "id": "SANITIZER_3", + "sanitizerType": "FunctionCallSanitizer", + "sanitizerScenario": "SANITIZER.VALIDATE_BY_FUNCTIONCALL", + "fsig": "agentWhiteList.includes", + "args": [ + "0" + ] + } + ] + } +] diff --git a/scripts/patch-uast-parser-php.js b/scripts/patch-uast-parser-php.js new file mode 100644 index 00000000..19aa64a1 --- /dev/null +++ b/scripts/patch-uast-parser-php.js @@ -0,0 +1,116 @@ +#!/usr/bin/env node +/** + * build-time patch：规避 pkg 对静态 require.resolve('*.wasm') 的 UTF-8 mangle。 + * + * 背景：pkg@5.8.1 扫描源码时，把 require.resolve(.wasm) 命中的文件归类为 script + * 走 bytecompile 管道，而该管道会把 wasm 当 UTF-8 文本做 decode/encode round-trip， + * 非法 UTF-8 字节（如 f0/e4）被替换成 EF BF BD（U+FFFD），wasm 字节错位 → WebAssembly + * instantiate 失败。 + * + * 本 patch 把 uast-parser-php 里那行 require.resolve 改成 path.join(__dirname, ...)， + * 使 pkg 静态扫描不再命中 wasm 文件；配合 pkg.assets 的 `node_modules/tree-sitter-php/*.wasm` + * 条目，wasm 走 asset 路径原始字节嵌入。 + * + * 幂等：已 patch 时检测 marker 跳过。 + * 自检：找不到原始 pattern 或 uast-parser-php 版本不匹配 → exit 1。 + */ + +const fs = require('fs') +const path = require('path') + +const ROOT = path.resolve(__dirname, '..') +const TARGET_FILE = path.join( + ROOT, + 'node_modules', + '@ant-yasa', + 'uast-parser-php', + 'dist', + 'src', + 'parser.js' +) +const PKG_JSON = path.join( + ROOT, + 'node_modules', + '@ant-yasa', + 'uast-parser-php', + 'package.json' +) + +const SUPPORTED_VERSIONS = ['0.2.12', '0.2.13'] + +// ─── 原始 pattern ─── +// require.resolve('tree-sitter-php/tree-sitter-php.wasm') +// 用正则以容忍 `'` 或 `"`，不容忍其他改写（上游真变了我们想 fail fast）。 +const ORIGINAL_PATTERN = /require\.resolve\(\s*['"]tree-sitter-php\/tree-sitter-php\.wasm['"]\s*\)/ + +// ─── patched 后的表达式 ─── +// 从 dist/src/parser.js 回溯 4 级到 node_modules/，再 tree-sitter-php/tree-sitter-php.wasm： +// src → dist → uast-parser-php → @ant-yasa → node_modules +// 用 inline require('path') 避免修改文件头部 import 区。 +const PATCHED_EXPR = + "require('path').join(__dirname, '..', '..', '..', '..', 'tree-sitter-php', 'tree-sitter-php.wasm')" + +// ─── marker：已被 patch 的标志（检测用于幂等）─── +const PATCHED_MARKER = "require('path').join(__dirname, '..', '..', '..', '..', 'tree-sitter-php'" + +function log(msg) { + console.log(`[patch-uast-parser-php] ${msg}`) +} + +function fail(msg) { + console.error(`[patch-uast-parser-php] ERROR: ${msg}`) + process.exit(1) +} + +function main() { + // 前置：目标文件存在 + if (!fs.existsSync(TARGET_FILE)) { + fail(`target file not found: ${TARGET_FILE}\nrun \`npm install\` first`) + } + if (!fs.existsSync(PKG_JSON)) { + fail(`uast-parser-php package.json not found: ${PKG_JSON}`) + } + + // 版本断言 + const pkg = JSON.parse(fs.readFileSync(PKG_JSON, 'utf-8')) + const version = pkg.version + if (!SUPPORTED_VERSIONS.includes(version)) { + fail( + `uast-parser-php version ${version} not in supported list [${SUPPORTED_VERSIONS.join( + ', ' + )}]. 升级了 uast-parser-php 请同步更新 scripts/patch-uast-parser-php.js 的 SUPPORTED_VERSIONS 和 pattern。` + ) + } + + const content = fs.readFileSync(TARGET_FILE, 'utf-8') + + // 幂等：已被 patch 直接返回 + if (content.includes(PATCHED_MARKER)) { + log(`already patched (uast-parser-php@${version}), skip`) + return + } + + // 自检：必须能匹配原始 pattern + const match = content.match(ORIGINAL_PATTERN) + if (!match) { + fail( + `original pattern not found in ${TARGET_FILE}\n` + + `expected regex: ${ORIGINAL_PATTERN}\n` + + `uast-parser-php@${version} 的 parser.js 可能已改写 wasm 加载方式，请 review 并更新本 patch script。` + ) + } + + // 执行替换 + const patched = content.replace(ORIGINAL_PATTERN, PATCHED_EXPR) + + // 后置自检：替换后必须能检到 marker + if (!patched.includes(PATCHED_MARKER)) { + fail(`post-patch sanity check failed: marker not found after replace`) + } + + fs.writeFileSync(TARGET_FILE, patched, 'utf-8') + log(`patched uast-parser-php@${version} parser.js: require.resolve → path.join`) + log(`file: ${TARGET_FILE}`) +} + +main() diff --git a/src/checker/callchain/callchain-checker.ts b/src/checker/callchain/callchain-checker.ts index 78b1c357..65a30be7 100644 --- a/src/checker/callchain/callchain-checker.ts +++ b/src/checker/callchain/callchain-checker.ts @@ -218,7 +218,7 @@ class CallchainChecker extends Checker { finding.sinkRule = arr[0] } else if (arr.length === 2) { finding.sinkRule = arr[0] - finding.sinkAttribute = arr[1] + finding.sinkAttribute = arr[1].split(',') } finding.sinkInfo = { @@ -321,7 +321,8 @@ class CallchainChecker extends Checker { findArgsAndAddNewFinding(node: any, callInfo: CallInfo | undefined, fclos: any, rule: any, state: any) { let ruleName = (rule as any).fsig if (typeof (rule as any).attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${(rule as any).attribute}` + const attrStr = Array.isArray((rule as any).attribute) ? (rule as any).attribute.join(',') : (rule as any).attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const callchainFinding = this.buildCallchainFinding( this.getCheckerId(), diff --git a/src/checker/callchain/js/js-callchain-checker.ts b/src/checker/callchain/js/js-callchain-checker.ts index dd8b41b9..c28e8398 100644 --- a/src/checker/callchain/js/js-callchain-checker.ts +++ b/src/checker/callchain/js/js-callchain-checker.ts @@ -135,6 +135,10 @@ class JsCallchainChecker extends CallchainChecker { } analyzer.entryPoints.push(...this.entryPoints) + + // 回填 processModule 阶段产生的 finding 的 entrypoint + // processModule 阶段 getCurrentEntryPoint() 返回 YASADefault，需要从 callstack 匹配正确的 entrypoint + this.backfillEntrypoints(constValue) } /** @@ -243,8 +247,7 @@ class JsCallchainChecker extends CallchainChecker { CallObj = CallFull.substring(0, lastIndexofCall) } if (CallObj !== RuleObj) { - const idx = CallObj.lastIndexOf('(') - const result = idx !== -1 ? CallObj.slice(0, idx) : CallObj + const result = QidUnifyUtil.removeParenthesesFromString(CallObj) if (result !== RuleObj) { if (!result.endsWith(`.${RuleObj}`) && !result.startsWith(`${RuleObj}.`)) { return false @@ -283,6 +286,43 @@ class JsCallchainChecker extends CallchainChecker { } return QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(fclos.sid) } + + /** + * 回填 processModule 阶段产生的 finding 中为 YASADefault 的 entrypoint + * 遍历已有 findings，从 callstackInfo 匹配 entryPoints 列表，找到正确的 entrypoint + * @param constValue + */ + backfillEntrypoints(constValue: any): void { + const CallchainOutputStrategy = require('../../common/output/callchain-output-strategy') + const category = this.resultManager?.findings?.[CallchainOutputStrategy.outputStrategyId] + if (!category || this.entryPoints.length === 0) return + + for (const finding of category) { + if (finding.entrypoint?.filePath !== constValue.YASA_DEFAULT) continue + + // 从 callstackInfo（已处理的调用链）中匹配 entryPoints + const callstackInfo = finding.callstackInfo + if (!callstackInfo || callstackInfo.length === 0) continue + + let matched = false + for (const frame of callstackInfo) { + if (frame.type === 1) continue // 跳过 sink 节点 + for (const ep of this.entryPoints) { + if (ep.filePath === frame.file && ep.functionName === frame.function) { + finding.entrypoint = { + filePath: ep.filePath, + functionName: ep.functionName, + attribute: ep.attribute, + funcReceiverType: ep.funcReceiverType || '', + } + matched = true + break + } + } + if (matched) break + } + } + } } module.exports = JsCallchainChecker diff --git a/src/checker/callchain/php/php-callchain-checker.ts b/src/checker/callchain/php/php-callchain-checker.ts new file mode 100644 index 00000000..15c27b81 --- /dev/null +++ b/src/checker/callchain/php/php-callchain-checker.ts @@ -0,0 +1,222 @@ +import type { CallInfo } from '../../../engine/analyzer/common/call-args' + +const _ = require('lodash') +const CallchainChecker = require('../callchain-checker') +const { matchSinkAtFuncCall, matchRegex } = require('../../taint/common-kit/sink-util') +const FullCallGraphFileEntryPoint = require('../../common/full-callgraph-file-entrypoint') +const EntryPoint = require('../../../engine/analyzer/common/entrypoint') +const Constant = require('../../../util/constant') +const Config = require('../../../config') +const AstUtil = require('../../../util/ast-util') +const FileUtil = require('../../../util/file-util') +const logger = require('../../../util/logger')(__filename) + +/** + * PHP callchain checker + * 仅检测 sink 匹配并输出调用链，不检查污点流 + * PHP 函数是全局的（无包前缀），fsig 匹配直接用函数名 + */ +class PhpCallchainChecker extends CallchainChecker { + entryPoints: any[] + + /** + * constructor + * @param resultManager + */ + constructor(resultManager: any) { + super(resultManager, 'callchain_php') + this.entryPoints = [] + } + + /** + * 启动触发：收集 PHP 入口点 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtStartOfAnalyze(analyzer: any, scope: any, node: any, state: any, info: any) { + const { topScope } = analyzer + + try { + logger.info('[PhpCallchainChecker] triggerAtStartOfAnalyze called') + + // 从 analyzer.checkerManager.Rules 获取规则配置 + const BasicRuleHandler = analyzer.getCheckerManager().Rules + if (BasicRuleHandler && BasicRuleHandler.getRules) { + const allRules = BasicRuleHandler.getRules() + if (Array.isArray(allRules) && allRules.length > 0) { + for (const rule of allRules) { + if (rule.checkerIds && rule.checkerIds.includes(this.getCheckerId())) { + _.merge(this.checkerRuleConfigContent, rule) + break + } + } + } + } + + // 使用 FullCallGraphFileEntryPoint 收集调用图边界入口 + if (Config.entryPointMode !== 'ONLY_CUSTOM') { + if (Config.cgAlgo === 'CHA' && analyzer.typeResolver) { + FullCallGraphFileEntryPoint.makeFullCallGraphByType(analyzer, analyzer.typeResolver) + } else { + FullCallGraphFileEntryPoint.makeFullCallGraph(analyzer) + } + const fullCallGraphEntrypoint = FullCallGraphFileEntryPoint.getAllEntryPointsUsingCallGraph( + analyzer.ainfo?.callgraph, + analyzer + ) + this.entryPoints.push(...fullCallGraphEntrypoint) + + // PHP 是脚本语言，也加入文件级别入口点 + const fileEntryPoints = FullCallGraphFileEntryPoint.getAllFileEntryPointsUsingFileManager(analyzer) + this.entryPoints.push(...fileEntryPoints) + } + } catch (err: any) { + logger.error(`[PhpCallchainChecker] Error in entrypoint collection: ${err.message}`) + logger.error(`[PhpCallchainChecker] Stack: ${err.stack}`) + } + + // 使用用户规则中指定的 entrypoint + const { entrypoints: ruleConfigEntryPoints } = this.checkerRuleConfigContent + if (!_.isEmpty(ruleConfigEntryPoints) && Config.entryPointMode !== 'SELF_COLLECT') { + logger.info(`[PhpCallchainChecker] Processing ${ruleConfigEntryPoints.length} custom entrypoints`) + for (const entrypoint of ruleConfigEntryPoints) { + logger.info(`[PhpCallchainChecker] Looking for: ${entrypoint.filePath}#${entrypoint.functionName}`) + + if (entrypoint.functionName) { + // PHP 全局函数匹配：直接按文件路径 + 函数名查找 + let entryPointSymVal = AstUtil.satisfy( + topScope.context.packages, + (n: any) => { + const sourcefile = n?.ast?.node?.loc?.sourcefile + const extracted = FileUtil.extractAfterSubstring(sourcefile, Config.maindirPrefix) + return ( + n.vtype === 'fclos' && + (extracted === entrypoint.filePath || + sourcefile?.endsWith(entrypoint.filePath) || + sourcefile?.includes(`/${entrypoint.filePath}`)) && + n?.ast?.node?.id?.name === entrypoint.functionName + ) + }, + (n: any, prop: any) => prop === '_field', + null, + false + ) + + if (_.isEmpty(entryPointSymVal)) { + logger.warn( + `[PhpCallchainChecker] match entryPoint fail for ${entrypoint.filePath}#${entrypoint.functionName}` + ) + continue + } + + const symValArray = Array.isArray(entryPointSymVal) + ? _.uniqBy(entryPointSymVal, (value: any) => value.ast?.fdef) + : [entryPointSymVal] + + for (const main of symValArray) { + if (main) { + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = main.parent + ep.argValues = [] + ep.entryPointSymVal = main + ep.filePath = entrypoint.filePath + ep.functionName = entrypoint.functionName + ep.attribute = entrypoint.attribute + this.entryPoints.push(ep) + } + } + } else { + // 文件级入口 + const ep = new EntryPoint(Constant.ENGIN_START_FILE_BEGIN) + ep.filePath = entrypoint.filePath + ep.attribute = entrypoint.attribute + this.entryPoints.push(ep) + } + } + } + + logger.info(`[PhpCallchainChecker] Total entryPoints: ${this.entryPoints.length}`) + analyzer.mainEntryPoints = this.entryPoints + } + + /** + * 函数调用触发：检测 sink 匹配 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtFunctionCallBefore(analyzer: any, scope: any, node: any, state: any, info: any) { + const { fclos, callInfo } = info + this.checkSinkMatch(node, fclos, callInfo, state) + } + + /** + * 检查 sink 匹配 + * PHP 函数是全局的，使用 matchSinkAtFuncCall 按函数名直接匹配 + * @param node + * @param fclos + * @param callInfo + * @param state + */ + checkSinkMatch(node: any, fclos: any, callInfo: CallInfo | undefined, state: any) { + if (fclos === undefined) { + return + } + const rules = this.checkerRuleConfigContent.sinks?.FuncCallTaintSink + + if (!rules || !callInfo) return + + // PHP 函数是全局的，优先用 matchSinkAtFuncCall 按函数名匹配 + let rule = matchSinkAtFuncCall(node, fclos, rules, callInfo) + rule = rule.length > 0 ? rule[0] : null + + // 若未匹配到，尝试用 fclos 的 sid/qid 做回退匹配 + if (!rule) { + const callName = this.resolvePhpCallName(fclos) + if (callName) { + for (const tspec of rules) { + if (tspec.fsig && tspec.fsig === callName) { + rule = tspec + break + } + if (tspec.fregex && matchRegex(tspec.fregex, callName)) { + rule = tspec + break + } + } + } + } + + if (rule) { + this.findArgsAndAddNewFinding(node, callInfo, fclos, rule, state) + } + } + + /** + * 从 fclos 解析 PHP 调用名称 + * PHP 全局函数无包前缀，直接取函数名 + * @param fclos + */ + resolvePhpCallName(fclos: any): string | undefined { + // 优先取 sid（函数标识符名称） + if (typeof fclos?.sid === 'string' && fclos.sid !== '') { + return fclos.sid + } + // 回退到 qid + if (typeof fclos?.qid === 'string' && fclos.qid !== '') { + return fclos.qid + } + // 回退到 AST 节点名 + if (fclos?.ast?.node?.id?.name) { + return fclos.ast.node.id.name + } + return undefined + } +} + +module.exports = PhpCallchainChecker diff --git a/src/checker/callchain/python/python-callchain-checker.ts b/src/checker/callchain/python/python-callchain-checker.ts index 37805d6f..01089f87 100644 --- a/src/checker/callchain/python/python-callchain-checker.ts +++ b/src/checker/callchain/python/python-callchain-checker.ts @@ -232,12 +232,13 @@ class PythonCallchainChecker extends CallchainChecker { getObj(fclos: any): any { if (typeof fclos?.sid !== 'undefined' && typeof fclos?.qid === 'undefined' && typeof fclos?._this === 'undefined') { const index = fclos?.sid.indexOf('>.') - return index !== -1 ? fclos?.sid.substring(index + 2) : fclos?.sid + const result = index !== -1 ? fclos?.sid.substring(index + 2) : fclos?.sid + return QidUnifyUtil.removeParenthesesFromString(result) } if (typeof fclos?.qid !== 'undefined' && typeof fclos.qid === 'string') { const index = fclos.qid.indexOf('>.') const result = index !== -1 ? fclos?.qid.substring(index + 2) : fclos?.qid - return QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(result) + return QidUnifyUtil.removeParenthesesFromString(QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(result)) } if (!(fclos === fclos?._this)) { return this.getObj(fclos._this) @@ -246,7 +247,7 @@ class PythonCallchainChecker extends CallchainChecker { const index = fclos?.sid.indexOf('>.') const result = index !== -1 ? fclos?.sid.substring(index + 2) : fclos?.sid if (result) { - return QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(result) + return QidUnifyUtil.removeParenthesesFromString(QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(result)) } } } diff --git a/src/checker/common/checker.ts b/src/checker/common/checker.ts index 2cf693fc..62d21ac6 100644 --- a/src/checker/common/checker.ts +++ b/src/checker/common/checker.ts @@ -54,8 +54,7 @@ class CheckerBase { } } } else if (!Array.isArray(ruleConfigContent)) { - handleException('', 'Error: ruleConfig must be an array!!', 'Error: ruleConfig must be an array!!') - process.exit(1) + throw new Error('ruleConfig must be an array') } } } diff --git a/src/checker/common/full-callgraph-file-entrypoint.ts b/src/checker/common/full-callgraph-file-entrypoint.ts index 36748110..71239832 100644 --- a/src/checker/common/full-callgraph-file-entrypoint.ts +++ b/src/checker/common/full-callgraph-file-entrypoint.ts @@ -349,9 +349,10 @@ function getAllFileEntryPointsUsingFileManager(analyzer: any): any[] { const entryPoints: any[] = [] if (options.language === 'python' || options.language === 'javascript') { if (analyzer?.fileManager) { - Object.values(analyzer?.fileManager).forEach((fileUUid: any) => { - const file = analyzer.symbolTable.get(fileUUid) - if (!file.ast.node || file.ast.node.type !== 'CompileUnit') return + Object.values(analyzer?.fileManager).forEach((fileEntry: any) => { + const fileUuid = typeof fileEntry === 'string' ? fileEntry : fileEntry.uuid + const file = analyzer.symbolTable.get(fileUuid) + if (!file?.ast?.node || file.ast.node.type !== 'CompileUnit') return const entryPoint = new EntryPoint(constValue.ENGIN_START_FILE_BEGIN) entryPoint.scopeVal = file entryPoint.argValues = undefined @@ -420,15 +421,17 @@ function getEntryPointsUsingCallGraphByKeyWords( } } - for (const file of Object.values(fileManager)) { - // const file = fileManager[loc.sourcefile] - const content = sourceLine.getCodeBySourceFile((file as any)?.ast?.node?.loc?.sourcefile) - if (file && content.includes(keyword)) { + for (const fileEntry of Object.values(fileManager)) { + const fileUuid = typeof fileEntry === 'string' ? fileEntry : (fileEntry as any).uuid + const file = symbolTable?.get(fileUuid) + if (!file) continue + const content = sourceLine.getCodeBySourceFile(file?.ast?.node?.loc?.sourcefile) + if (content.includes(keyword)) { const entryPoint = new EntryPoint(constValue.ENGIN_START_FILE_BEGIN) entryPoint.scopeVal = file entryPoint.argValues = undefined entryPoint.functionName = undefined - entryPoint.filePath = (file as any)?.ast?.node?.sourcefile || (file as any)?.ast?.node?.loc?.sourcefile + entryPoint.filePath = file?.ast?.node?.sourcefile || file?.ast?.node?.loc?.sourcefile entryPoint.attribute = 'FileEntryPointByLoc' entryPoint.packageName = undefined entryPoint.entryPointSymVal = file @@ -486,17 +489,21 @@ function getEntryPointsUsingCallGraphByLoc(locs: any[], callGraph: any, fileMana } } } else { - const file = fileManager[loc.sourcefile] - if (file) { - const entryPoint = new EntryPoint(constValue.ENGIN_START_FILE_BEGIN) - entryPoint.scopeVal = file - entryPoint.argValues = undefined - entryPoint.functionName = undefined - entryPoint.filePath = (file as any)?.ast?.node?.sourcefile || (file as any)?.ast?.node?.loc?.sourcefile - entryPoint.attribute = 'FileEntryPointByLoc' - entryPoint.packageName = undefined - entryPoint.entryPointSymVal = file - newEntryPointList.push(entryPoint) + const fileEntry = fileManager[loc.sourcefile] + if (fileEntry) { + const fileUuid = typeof fileEntry === 'string' ? fileEntry : (fileEntry as any).uuid + const file = symbolTable?.get(fileUuid) + if (file) { + const entryPoint = new EntryPoint(constValue.ENGIN_START_FILE_BEGIN) + entryPoint.scopeVal = file + entryPoint.argValues = undefined + entryPoint.functionName = undefined + entryPoint.filePath = file?.ast?.node?.sourcefile || file?.ast?.node?.loc?.sourcefile + entryPoint.attribute = 'FileEntryPointByLoc' + entryPoint.packageName = undefined + entryPoint.entryPointSymVal = file + newEntryPointList.push(entryPoint) + } } } } diff --git a/src/checker/common/output/callchain-output-strategy.ts b/src/checker/common/output/callchain-output-strategy.ts index f1da9d4c..f3726fce 100644 --- a/src/checker/common/output/callchain-output-strategy.ts +++ b/src/checker/common/output/callchain-output-strategy.ts @@ -61,8 +61,8 @@ class CallchainOutputStrategy extends OutputStrategy { printf(`\nTotal callchain findings: ${callchainFindings.length}\n`) callchainFindings.forEach((finding: any, index: number) => { printf(`\n[${index + 1}] Sink matched: ${finding.sinkRule}`) - if (finding.sinkAttribute) { - printf(` Attribute: ${finding.sinkAttribute}`) + if (finding.sinkAttribute && finding.sinkAttribute.length > 0) { + printf(` Attribute: ${finding.sinkAttribute.join(',')}`) } printf(` Entry point: ${finding.entrypoint?.functionName || 'N/A'}`) printf(` Location: ${finding.sourcefile}:${finding.line}`) diff --git a/src/checker/common/output/taint-output-strategy.ts b/src/checker/common/output/taint-output-strategy.ts index 4666327b..a83682cf 100644 --- a/src/checker/common/output/taint-output-strategy.ts +++ b/src/checker/common/output/taint-output-strategy.ts @@ -24,6 +24,26 @@ const { const AstUtil = require('../../../util/ast-util') const { handleException } = require('../../../engine/analyzer/common/exception-handler') +/** + * 过滤掉合成的 synthetic step（Plan A）。 + * + * 背景：R21 判据 A 在 CO 模式下自动在 finding.trace 中注入一对 `CALL: ` + `ARG PASS: ` synthetic + * step（带 `_synthetic: true` 内部标记）以补齐 callstack 桥接 fclos 的 trace 可见性；但 `isNewFinding` + * 的 CO 折叠判据依赖"raw trace 形态"判定两条 finding 是否可合并。合成 step 不该参与可合并性判定， + * 否则原本 degenerate 的 SOURCE+SINK finding 在注入合成 step 后会被误判为不同 finding → R19 CO + * 折叠语义破损。 + * + * 该 filter 常驻生效：非 CO 模式下 finding.trace 本就不含带 `_synthetic` 标记的 step，返回值与原数组 + * 等价（no-op）；CO 模式下过滤合成 step 后恢复 R19 折叠语义。 + * `_synthetic` 字段不经 SARIF 序列化路径（prepareLocation 只读 file/line/tag/node/affectedNodeName）， + * 不影响输出。 + * @param trace + */ +function filterOutSyntheticSteps(trace: any): any[] | undefined { + if (!Array.isArray(trace)) return trace + return trace.filter((item: any) => item?._synthetic !== true) +} + /** * 比较单个 trace item 是否相等（file、line、tag、affectedNodeName） */ @@ -60,6 +80,80 @@ function isTraceEqual(trace1: any[] | undefined, trace2: any[] | undefined): boo return true } +/** + * 取 trace 中第一个 tag=SOURCE 的 item 的位置键 + */ +function extractSourceKey(finding: any): string | null { + const trace = finding?.trace + if (!Array.isArray(trace)) return null + for (const item of trace) { + if (item?.tag === 'SOURCE: ') { + const file = item.node?.loc?.sourcefile || item.file || '' + const line = item.node?.loc?.start?.line ?? (Array.isArray(item.line) ? item.line[0] : item.line) ?? -1 + const col = item.node?.loc?.start?.column ?? -1 + return `${file}:${line}:${col}` + } + } + return null +} + +/** + * 取 sink 位置键：优先 finding.node 的 loc，否则 trace 末尾 tag=SINK 的 item + */ +function extractSinkKey(finding: any): string | null { + const n = finding?.node + if (n?.loc) { + const file = n.loc.sourcefile || finding.sourcefile || '' + const line = n.loc.start?.line ?? -1 + const col = n.loc.start?.column ?? -1 + return `${file}:${line}:${col}` + } + const trace = finding?.trace + if (Array.isArray(trace)) { + for (let i = trace.length - 1; i >= 0; i--) { + const item = trace[i] + if (item?.tag === 'SINK: ') { + const file = item.node?.loc?.sourcefile || item.file || '' + const line = item.node?.loc?.start?.line ?? (Array.isArray(item.line) ? item.line[0] : item.line) ?? -1 + const col = item.node?.loc?.start?.column ?? -1 + return `${file}:${line}:${col}` + } + } + } + return null +} + +/** + * 同 source+sink 位置的 finding 只保留 trace 最短的一条 + * 只对 PHP（finding.type === 'taint_flow_php_input'）启用；其它语言原样透传 + */ +function dedupBySourceSinkShortestTrace(taintFindings: any[]): any[] { + if (!Array.isArray(taintFindings) || taintFindings.length === 0) return taintFindings + const phpGroups = new Map() + const nonPhpAndUngrouped: any[] = [] + for (const finding of taintFindings) { + if (finding?.type !== 'taint_flow_php_input') { + nonPhpAndUngrouped.push(finding) + continue + } + const srcKey = extractSourceKey(finding) + const sinkKey = extractSinkKey(finding) + if (!srcKey || !sinkKey) { + nonPhpAndUngrouped.push(finding) + continue + } + const groupKey = `${srcKey}|${sinkKey}` + const traceLen = Array.isArray(finding.trace) ? finding.trace.length : Number.POSITIVE_INFINITY + const prev = phpGroups.get(groupKey) + if (!prev || traceLen < prev.len) { + phpGroups.set(groupKey, { finding, len: traceLen }) + } + } + const result: any[] = [...nonPhpAndUngrouped] + for (const { finding } of phpGroups.values()) result.push(finding) + return result +} + /** * */ @@ -85,9 +179,13 @@ class TaintOutputStrategy extends OutputStrategy { let reportFilePath if (resultManager) { const allFindings = resultManager.getFindings() - const taintFindings = allFindings[TaintOutputStrategy.outputStrategyId] + let taintFindings = allFindings[TaintOutputStrategy.outputStrategyId] let callgraphFindings if (taintFindings) { + // 后处理：同 source+sink 位置只保留 trace 最短的 finding（仅 PHP 启用） + const deduped = dedupBySourceSinkShortestTrace(taintFindings as any[]) + allFindings[TaintOutputStrategy.outputStrategyId] = deduped + taintFindings = deduped if (printf) { TaintFindingUtil.outputCheckerResultToConsole(taintFindings, printf) } @@ -107,9 +205,14 @@ class TaintOutputStrategy extends OutputStrategy { * @param finding */ static isNewFinding(resultManager: IResultManager, finding: TaintFinding): boolean { + // finding 为 null 表示上游（如 verifyCallstackEdgeInvariant 校验未通过）已判定丢弃，返回 false 让 caller 的 `if (!isNewFinding) continue` 跳过 + if (!finding) return false try { const category = resultManager?.findings[TaintOutputStrategy.outputStrategyId] if (!category) return true + // Plan A：在所有依赖 trace 形态的折叠判据前，先过滤 synthetic step（R21 判据 A 注入的合成步）； + // 非 CO 模式下 finding.trace / issue.trace 不含带 _synthetic 标记的 step，filter 返回等价数组（no-op）。 + const findingTraceNoSynthetic = filterOutSyntheticSteps(finding.trace) for (const issue of category) { if ( issue.line === finding.line && @@ -124,21 +227,31 @@ class TaintOutputStrategy extends OutputStrategy { } } else if (isTraceEqual(issue.trace, finding.trace)) { return false - } else if (isTraceEqual(getOutputTrace(issue), getOutputTrace(finding))) { + } else if ( + isTraceEqual( + filterOutSyntheticSteps(getOutputTrace(issue)), + filterOutSyntheticSteps(getOutputTrace(finding)) + ) + ) { // callstack-only output may collapse distinct internal traces into the same // user-visible chain; suppress duplicate visible findings in that mode. + // Plan A：比较前过滤合成 step，确保 R21 判据 A 在 CO 下原折叠语义不破。 return false - } else if ( - finding.trace && finding.trace.length === 2 && - finding.trace[0]?.tag === 'SOURCE: ' && finding.trace[1]?.tag === 'SINK: ' && - issue.trace && issue.trace.length > 2 && - issue.trace[0]?.tag === 'SOURCE: ' && - isTraceItemEqual(finding.trace[0], issue.trace[0]) && - isTraceItemEqual(finding.trace[1], issue.trace[issue.trace.length - 1]) - ) { + } else { // TaintRecord._clone 拷贝 trace 数组导致部分 finding 的 trace 退化为仅 SOURCE+SINK（len=2）， // 当已有同 SOURCE 且同 SINK 的更长 trace finding 时，跳过退化 finding。 - return false + // Plan A：判定基于"去合成 step 后的 trace"，避免 R21 注入的 CALL/ARG PASS 把原 len=2 退化体变成 len>2 逃过折叠。 + const issueTraceNoSynthetic = filterOutSyntheticSteps(issue.trace) + if ( + Array.isArray(findingTraceNoSynthetic) && findingTraceNoSynthetic.length === 2 && + findingTraceNoSynthetic[0]?.tag === 'SOURCE: ' && findingTraceNoSynthetic[1]?.tag === 'SINK: ' && + Array.isArray(issueTraceNoSynthetic) && issueTraceNoSynthetic.length > 2 && + issueTraceNoSynthetic[0]?.tag === 'SOURCE: ' && + isTraceItemEqual(findingTraceNoSynthetic[0], issueTraceNoSynthetic[0]) && + isTraceItemEqual(findingTraceNoSynthetic[1], issueTraceNoSynthetic[issueTraceNoSynthetic.length - 1]) + ) { + return false + } } } } @@ -286,3 +399,4 @@ class TaintOutputStrategy extends OutputStrategy { } module.exports = TaintOutputStrategy +module.exports.dedupBySourceSinkShortestTrace = dedupBySourceSinkShortestTrace diff --git a/src/checker/common/ql-uast-convert/converter.ts b/src/checker/common/ql-uast-convert/converter.ts index 1d617745..35d93133 100644 --- a/src/checker/common/ql-uast-convert/converter.ts +++ b/src/checker/common/ql-uast-convert/converter.ts @@ -273,7 +273,8 @@ function calcEntryPointAndRun(options: any, fileManager: any, analyzer: any): vo for (const filename in fileManager) { for (const sourcefile in options.FlowConfig.sourcefiles) { if (filename.endsWith(sourcefile)) { - const fileUuid = fileManager[filename] + const fileEntry = fileManager[filename] + const fileUuid = typeof fileEntry === 'string' ? fileEntry : fileEntry?.uuid const filescope = analyzer.symbolTable.get(fileUuid) let entryPoints = AstUtilConverter.satisfy( filescope, diff --git a/src/checker/common/rules-basic-handler.ts b/src/checker/common/rules-basic-handler.ts index a0ae42e7..a13b1474 100644 --- a/src/checker/common/rules-basic-handler.ts +++ b/src/checker/common/rules-basic-handler.ts @@ -5,6 +5,7 @@ import { getBoundCallFromInfo, type CallInfo, } from '../../engine/analyzer/common/call-args' +import type { Precondition } from './value/precondition' const _ = require('lodash') const config = require('../../config') @@ -72,6 +73,9 @@ function normalizeSelectors( let rules: any[] let preprocessReady: boolean = false +/** 全局 precondition 存储，按 id 索引 */ +let preconditionMap: Map | undefined + function normalizeTraceStrategy(strategy: any): string | undefined { if (strategy === 'folded') return 'callstack-only' if (strategy === 'callstack-only' || strategy === 'full') return strategy @@ -82,7 +86,7 @@ function normalizeTraceStrategy(strategy: any): string | undefined { * * @param ruleConfigPath */ -function getRules(ruleConfigPath: string): any[] { +function getRules(ruleConfigPath?: string): any[] { if (!rules) { try { if (ruleConfigPath) { @@ -96,7 +100,7 @@ function getRules(ruleConfigPath: string): any[] { `Error in rule-basic-handler.getRules: json in ruleConfig is not correct, path is ${ruleConfigPath || config.ruleConfigFile}`, `Error in rule-basic-handler.getRules: json in ruleConfig is not correct, path is ${ruleConfigPath || config.ruleConfigFile}` ) - process.exit(1) + throw new Error(`Failed to parse ruleConfig JSON: ${ruleConfigPath || config.ruleConfigFile}`) } } if (!rules) { @@ -221,7 +225,7 @@ function initRules(): void { * @param i * @returns {boolean} */ -function matchField(node: any, marray: string[], i: number): boolean { +export function matchField(node: any, marray: string[], i: number): boolean { /** * * @param el @@ -237,6 +241,43 @@ function matchField(node: any, marray: string[], i: number): boolean { } else return name === el } + /** + * CallExpression 分支：链式调用中段匹配 + * callee 是 MemberAccess 时，匹配方法名后 i===0 即成功（根对象任意），否则递归 callee.object + * callee 是 Identifier 时，匹配名称并要求 i===0 + * @param el 当前待匹配的 fsig 段 + * @param callNode CallExpression 节点 + * @param segments fsig 段数组 + * @param idx 当前段索引 + * @returns {boolean} 是否匹配 + */ + function matchCallExpression(el: string, callNode: any, segments: string[], idx: number): boolean { + const { callee } = callNode + if (callee?.type === 'MemberAccess') { + if (!matchPrefix(el, callee.property?.name)) return false + if (idx === 0) return true + return matchField(callee.object, segments, idx - 1) + } + if (callee?.type === 'Identifier') { + return matchPrefix(el, callee.name) && idx === 0 + } + return false + } + + /** + * NewExpression 分支：构造器调用 + * `new` 本身不占 fsig 段，直接把 callee（类名 Identifier 或 FQN MemberAccess）透传给 matchField + * 语义：fsig "Foo" 匹配 `new Foo(x)` 里的 Foo；fsig "java.io.File" 匹配 `new java.io.File(x)` + * @param el 当前待匹配的 fsig 段（由被调用方读取，本函数不消费） + * @param newNode NewExpression 节点 + * @param segments fsig 段数组 + * @param idx 当前段索引（透传，不 -1） + * @returns {boolean} 是否匹配 + */ + function matchNewExpression(el: string, newNode: any, segments: string[], idx: number): boolean { + return matchField(newNode.callee, segments, idx) + } + const el = marray[i] if (el === '**') return true switch (node.type) { @@ -253,8 +294,15 @@ function matchField(node: any, marray: string[], i: number): boolean { case 'ThisExpression': { return matchPrefix(el, 'this') && i === 0 } + case 'CallExpression': { + return matchCallExpression(el, node, marray, i) + } + case 'NewExpression': { + return matchNewExpression(el, node, marray, i) + } + default: + return false } - return false } /** @@ -319,6 +367,63 @@ function getFinding(type: string, description: string, node: any, argNode?: any) return finding } +/** + * 从所有规则中加载 preconditions 配置，构建全局索引 + */ +function loadAndStoreAllPreconditions(): void { + if (preconditionMap) { + return + } + preconditionMap = new Map() + if (Array.isArray(getRules()) && getRules().length > 0) { + for (const rule of getRules()) { + if (Array.isArray(rule.preconditions)) { + for (const precondition of rule.preconditions) { + if (precondition.id) { + preconditionMap.set(precondition.id, precondition as Precondition) + } + } + } + } + } +} + +/** + * 根据 id 列表查找 precondition 定义 + */ +function findPreconditionByIds(ids: string[]): Precondition[] { + const result: Precondition[] = [] + if (!ids || ids.length === 0) { + return result + } + if (!preconditionMap) { + loadAndStoreAllPreconditions() + } + if (!preconditionMap) { + return result + } + for (const id of ids) { + const p = preconditionMap.get(id) + if (p) { + result.push(p) + } + } + return result +} + +/** + * 获取所有已加载的 preconditions + */ +function findAllPreconditions(): Precondition[] { + if (!preconditionMap) { + loadAndStoreAllPreconditions() + } + if (!preconditionMap) { + return [] + } + return Array.from(preconditionMap.values()) +} + /** * * @type {{getRule: (function(*, *): *), compileAttackTrace: *, introduceTaint: introduceTaint}} @@ -333,4 +438,7 @@ module.exports = { prepareArgsByType, matchPackageValueSink, getFinding, + loadAndStoreAllPreconditions, + findPreconditionByIds, + findAllPreconditions, } diff --git a/src/checker/common/value/precondition.ts b/src/checker/common/value/precondition.ts new file mode 100644 index 00000000..1d0add00 --- /dev/null +++ b/src/checker/common/value/precondition.ts @@ -0,0 +1,46 @@ +/** ruleconfig 中的前置条件定义，语义为"taint 必须经过此函数，sink 才有效"；sink rule 声明多个 preconditionIds 时采用 OR 语义——taint 命中任一即可 */ +interface Precondition { + /** 唯一标识，与 sink rule 中 preconditionIds 对应（sink rule 声明多个 id 时为 OR 语义） */ + id: string + /** 前置条件类型，如 FunctionCallPrecondition */ + preconditionType: string + /** 前置条件场景，如 PRECONDITION.VALIDATE_BY_FUNCTIONCALL */ + preconditionScenario: string + /** 被调用方类型，用于函数匹配 */ + calleeType?: string + /** 函数签名，用于函数匹配 */ + fsig?: string + /** 参数位置列表 */ + args?: (string | number)[] + /** 参数数量约束（复用 sanitizer 匹配逻辑） */ + argNum?: number + /** 正则匹配（复用 sanitizer 匹配逻辑） */ + fregex?: string +} + +/** + * 将 Precondition 转换为 sanitizer 匹配函数兼容的格式 + * sanitizerType 映射自 preconditionType，sanitizerScenario 映射自 preconditionScenario + */ +interface PreconditionAsSanitizer extends Precondition { + sanitizerType: string + sanitizerScenario: string +} + +/** 将 precondition 转换为 sanitizer 匹配兼容对象 */ +function toPreconditionAsSanitizer(p: Precondition): PreconditionAsSanitizer { + const TYPE_MAP: Record = { + FunctionCallPrecondition: 'FunctionCallSanitizer', + } + const SCENARIO_MAP: Record = { + 'PRECONDITION.VALIDATE_BY_FUNCTIONCALL': 'SANITIZER.VALIDATE_BY_FUNCTIONCALL', + } + return { + ...p, + sanitizerType: TYPE_MAP[p.preconditionType] ?? p.preconditionType, + sanitizerScenario: SCENARIO_MAP[p.preconditionScenario] ?? p.preconditionScenario, + } +} + +export type { Precondition, PreconditionAsSanitizer } +export { toPreconditionAsSanitizer } diff --git a/src/checker/sanitizer/sanitizer-checker.ts b/src/checker/sanitizer/sanitizer-checker.ts index 35805fae..7fe0ac81 100644 --- a/src/checker/sanitizer/sanitizer-checker.ts +++ b/src/checker/sanitizer/sanitizer-checker.ts @@ -1,4 +1,5 @@ import type { CallInfo } from '../../engine/analyzer/common/call-args' +import { toPreconditionAsSanitizer, type Precondition, type PreconditionAsSanitizer } from '../common/value/precondition' const _ = require('lodash') const BasicRuleHandler = require('../common/rules-basic-handler') @@ -28,8 +29,37 @@ const SANITIZER = { VALIDATE_BY_BINARYOPERATION: 'SANITIZER.VALIDATE_BY_BINARYOPERATION', }, } +const PRECONDITION = { + PRECONDITION_TYPE: { + FUNCTION_CALL_PRECONDITION: 'FunctionCallPrecondition', + }, + PRECONDITION_SCENARIO: { + VALIDATE_BY_FUNCTIONCALL: 'PRECONDITION.VALIDATE_BY_FUNCTIONCALL', + }, +} + +/** + * 根据 sanitizer 规则的 from/to 字段推断 scenario + * - to 包含 "R" → FILTER_BY_FUNCTIONCALL（返回值带 sanitizer tag） + * - to 包含以 "P" 开头的项 → VALIDATE_BY_FUNCTIONCALL（参数带 sanitizer tag） + * - 其他 → DEFAULT + */ +function inferSanitizerScenario(item: { from?: string; to?: string | string[] }): string { + const toArr = Array.isArray(item.to) ? item.to : item.to ? [item.to] : [] + if (toArr.some((t: string) => t === 'R')) { + return SANITIZER.SANITIZER_SCENARIO.FILTER_BY_FUNCTIONCALL + } + if (toArr.some((t: string) => /^P\d*$/.test(t))) { + return SANITIZER.SANITIZER_SCENARIO.VALIDATE_BY_FUNCTIONCALL + } + return SANITIZER.SANITIZER_SCENARIO.DEFAULT +} + const callstackSanitizers = new Set() +/** 缓存：precondition 转为 sanitizer 兼容格式的列表 */ +let preconditionAsSanitizerCache: PreconditionAsSanitizer[] | undefined + /** * */ @@ -78,6 +108,8 @@ class SanitizerChecker extends Checker { */ triggerAtFunctionCallAfter(analyzer: any, scope: any, node: any, state: any, info: any): void { const { fclos, ret, callInfo } = info + // legacy 兼容：Java 分析器传 argvalues 而非 callInfo，转换为 CallInfo 格式 + const effectiveCallInfo: CallInfo | undefined = callInfo ?? (Array.isArray(info.argvalues) ? { callArgs: { args: info.argvalues.map((v: any, i: number) => ({ index: i, value: v })) } } as CallInfo : undefined) const sanitizers = SanitizerChecker.findAllSanitizers() if (sanitizers) { SanitizerChecker.checkAddOrDeleteFunctionCallSanitizer( @@ -85,11 +117,13 @@ class SanitizerChecker extends Checker { node, fclos, ret, - callInfo, + effectiveCallInfo, scope, info?.callstack ) } + // precondition 打标：复用 sanitizer 匹配逻辑 + SanitizerChecker.checkAndTagPreconditions(node, fclos, ret, effectiveCallInfo, scope, info?.callstack) } /** @@ -103,6 +137,8 @@ class SanitizerChecker extends Checker { */ triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any): void { const { fclos, ret, callInfo } = info + // legacy 兼容：Java 分析器传 argvalues 而非 callInfo，转换为 CallInfo 格式 + const effectiveCallInfo: CallInfo | undefined = callInfo ?? (Array.isArray(info.argvalues) ? { callArgs: { args: info.argvalues.map((v: any, i: number) => ({ index: i, value: v })) } } as CallInfo : undefined) const sanitizers = SanitizerChecker.findAllSanitizers() if (sanitizers) { SanitizerChecker.checkAddOrDeleteFunctionCallSanitizer( @@ -110,11 +146,13 @@ class SanitizerChecker extends Checker { node, fclos, ret, - callInfo, + effectiveCallInfo, scope, info?.callstack ) } + // precondition 打标：复用 sanitizer 匹配逻辑 + SanitizerChecker.checkAndTagPreconditions(node, fclos, ret, effectiveCallInfo, scope, info?.callstack) } /** @@ -155,7 +193,7 @@ class SanitizerChecker extends Checker { node: any, fclos: any, ret: any, - callInfo: CallInfo, + callInfo: CallInfo | undefined, scope: any, callstack: any ): void { @@ -311,10 +349,30 @@ class SanitizerChecker extends Checker { SanitizerChecker.sanitizerMap = new Map() if (Array.isArray(BasicRuleHandler.getRules()) && BasicRuleHandler.getRules().length > 0) { for (const rule of BasicRuleHandler.getRules()) { + if (!rule.sanitizers || typeof rule.sanitizers !== 'object') { + continue + } if (Array.isArray(rule.sanitizers)) { + // 旧格式：sanitizers 是扁平数组，每项已含 id/sanitizerType for (const sanitizer of rule.sanitizers) { SanitizerChecker.sanitizerMap.set(sanitizer.id, sanitizer) } + } else { + // 新格式：sanitizers 是 { sanitizerType: [...items] } 的 Object + for (const [type, items] of Object.entries(rule.sanitizers)) { + if (!Array.isArray(items)) { + continue + } + for (const item of items as any[]) { + const sanitizer = { + ...item, + sanitizerType: type, + id: item.id || item.fsig, + sanitizerScenario: item.sanitizerScenario || inferSanitizerScenario(item), + } + SanitizerChecker.sanitizerMap.set(sanitizer.id, sanitizer) + } + } } } } @@ -437,12 +495,13 @@ class SanitizerChecker extends Checker { * @param scope * @returns {*[]} */ - static findMatchedSanitizerOfFunctionCall(sanitizers: any[], node: any, fclos: any, scope: any, callInfo: CallInfo): any[] { + static findMatchedSanitizerOfFunctionCall(sanitizers: any[], node: any, fclos: any, scope: any, callInfo: CallInfo | undefined, skipCache?: boolean): any[] { if (!BasicRuleHandler.getPreprocessReady()) { return [] } - if (node?._meta?.nodehash && SanitizerChecker.matchSanitizerResultMap.has(node._meta.nodehash)) { + // precondition 匹配复用此方法但传入不同规则列表，必须跳过缓存避免与 sanitizer 结果混淆 + if (!skipCache && node?._meta?.nodehash && SanitizerChecker.matchSanitizerResultMap.has(node._meta.nodehash)) { return SanitizerChecker.matchSanitizerResultMap.get(node._meta.nodehash) } @@ -475,7 +534,8 @@ class SanitizerChecker extends Checker { matchedSanitizers.push(...matchedSanitizersWithCalleeType) } - if (node?._meta?.nodehash) { + // 仅缓存 sanitizer 的结果，precondition 不写入缓存 + if (!skipCache && node?._meta?.nodehash) { SanitizerChecker.matchSanitizerResultMap.set(node._meta.nodehash, matchedSanitizers) } @@ -665,6 +725,87 @@ class SanitizerChecker extends Checker { return resultArray } + + /** + * 获取所有 precondition（转换为 sanitizer 兼容格式），带缓存 + */ + static findAllPreconditionsAsSanitizers(): PreconditionAsSanitizer[] { + if (preconditionAsSanitizerCache) { + return preconditionAsSanitizerCache + } + const preconditions: Precondition[] = BasicRuleHandler.findAllPreconditions() + preconditionAsSanitizerCache = preconditions.map(toPreconditionAsSanitizer) + return preconditionAsSanitizerCache + } + + /** + * 检查函数调用是否匹配 precondition，匹配时在 taint 上打 tag + * 复用 sanitizer 的函数匹配逻辑，scenario 为 VALIDATE_BY_FUNCTIONCALL 时标记参数 + */ + static checkAndTagPreconditions( + node: any, + fclos: any, + ret: any, + callInfo: CallInfo | undefined, + scope: any, + callstack: any + ): void { + const preconditionsAsSanitizer = SanitizerChecker.findAllPreconditionsAsSanitizers() + if (preconditionsAsSanitizer.length === 0) { + return + } + const matched = SanitizerChecker.findMatchedSanitizerOfFunctionCall( + preconditionsAsSanitizer, + node, + fclos, + scope, + callInfo, + true // skipCache：precondition 和 sanitizer 使用不同规则列表，不能共享缓存 + ) + if (!matched || matched.length === 0) { + return + } + for (const matchedPrecondition of matched) { + // precondition 场景目前只支持 VALIDATE_BY_FUNCTIONCALL + const mappedScenario = matchedPrecondition.sanitizerScenario ?? SANITIZER.SANITIZER_SCENARIO.VALIDATE_BY_FUNCTIONCALL + if (mappedScenario === SANITIZER.SANITIZER_SCENARIO.VALIDATE_BY_FUNCTIONCALL) { + const args = BasicRuleHandler.prepareArgs(callInfo, fclos, matchedPrecondition) + // precondition 语义：只有参数携带 taint 时才打 tag（arg + receiver） + // 确保 taint 必须流经 precondition 函数的参数 + const argHasTaint = args?.some((arg: any) => arg?.taint?.isTaintedRec) + if (argHasTaint) { + if (args) { + for (const arg of args) { + SanitizerChecker.addSanitizerInSymbolValue(matchedPrecondition, node, arg, callstack) + } + } + // 对 MemberAccess 调用（如 request.setStatement(userInput)），在 receiver 上也打 tag + const receiver = typeof fclos?.getThisObj === 'function' ? fclos.getThisObj() : undefined + if (receiver) { + SanitizerChecker.addSanitizerInSymbolValue(matchedPrecondition, node, receiver, callstack) + } + } + } + } + } + + /** + * 在 taint tags 中查找匹配指定 precondition ids 的 tag + * 返回匹配到的 tag 列表 + */ + static findMatchedPreconditionTags(preconditionIds: string[], tags: any[]): any[] { + const result: any[] = [] + if (!preconditionIds || preconditionIds.length === 0 || !tags) { + return result + } + const idSet = new Set(preconditionIds) + for (const tagObj of tags) { + if (tagObj instanceof SanitizerTag && tagObj.id && idSet.has(tagObj.id)) { + result.push(tagObj) + } + } + return result + } } module.exports = SanitizerChecker diff --git a/src/checker/sdk/get-file-ast-checker.ts b/src/checker/sdk/get-file-ast-checker.ts index 89c895be..86b44ccb 100644 --- a/src/checker/sdk/get-file-ast-checker.ts +++ b/src/checker/sdk/get-file-ast-checker.ts @@ -63,8 +63,8 @@ class GetFileAstChecker extends Checker { if (typeof fileValue === 'string' && fileValue.startsWith('symuuid_')) { fileValue = this.symbolTable.get(this.fileManager[this.input]) } - if (fileValue?.ast?.node) { - finding.output = JSON.stringify(fileValue.ast?.node, (key: string, value: any) => { + if (fileValue?.astNode) { + finding.output = JSON.stringify(fileValue.astNode, (key: string, value: any) => { // 如果属性名是 'parent'，则返回 undefined 表示排除 if (key === 'parent') { return undefined diff --git a/src/checker/taint/common-kit/call-info-util.ts b/src/checker/taint/common-kit/call-info-util.ts new file mode 100644 index 00000000..5374bd2f --- /dev/null +++ b/src/checker/taint/common-kit/call-info-util.ts @@ -0,0 +1,23 @@ +import type { CallArg, CallInfo } from '../../../engine/analyzer/common/call-args' + +/** + * 统一处理 checkAtNewExprAfter payload 的 callInfo / legacy argvalues 不对称问题。 + * - common analyzer 在 processNewObject 传 callInfo（analyzer.ts:3707-3714） + * - python/go-analyzer 早期走 legacy，只传 argvalues（兜底） + * 参考 sanitizer-checker.ts:112/141 的既有兼容模式。 + */ +export function getOrBuildCallInfo(info: any): CallInfo | undefined { + if (info?.callInfo) return info.callInfo + const argvalues = info?.argvalues + if (!Array.isArray(argvalues)) return undefined + const args: CallArg[] = argvalues.map((v: any, i: number) => ({ + index: i, + value: v, + kind: 'positional', + })) + return { callArgs: { args } } +} + +module.exports = { + getOrBuildCallInfo, +} diff --git a/src/checker/taint/common-kit/sink-util.ts b/src/checker/taint/common-kit/sink-util.ts index b0a98893..d9e152f8 100644 --- a/src/checker/taint/common-kit/sink-util.ts +++ b/src/checker/taint/common-kit/sink-util.ts @@ -24,6 +24,8 @@ interface SinkRule { fsig?: string fregex?: string calleeType?: string + /** sink 关联的前置条件 id 列表，采用 OR 语义：taint 上命中任一 id 对应的 tag 即生成 finding */ + preconditionIds?: string[] [key: string]: any } @@ -92,6 +94,9 @@ function matchSinkAtFuncCallWithCalleeType( continue } + // Go 指针类型 sink 规则的 calleeType 带 * 前缀（如 *Collection），引擎解析的类型不带，需 normalize + const calleeTypeBase = tspec.calleeType?.startsWith('*') ? tspec.calleeType.slice(1) : '' + if (tspec.fsig) { if ((!tspec.calleeType || tspec.calleeType === '') && tspec.fsig === AstUtilSinkUtil.prettyPrint(callExpr)) { res.push(tspec) @@ -99,6 +104,8 @@ function matchSinkAtFuncCallWithCalleeType( callExpr.type === 'MemberAccess' && (AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType) === tspec.calleeType || AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType).endsWith(`.${tspec.calleeType}`) || + (calleeTypeBase && (AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType).endsWith(`.${calleeTypeBase}`))) || tspec.calleeType === '*') && `${AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.vagueType).replace(/"/g, '')}.${AstUtilSinkUtil.prettyPrint( fclos.property @@ -109,6 +116,8 @@ function matchSinkAtFuncCallWithCalleeType( (callExpr.type === 'MemberAccess' || callExpr.type === 'Identifier') && (AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType) === tspec.calleeType || AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType).endsWith(`.${tspec.calleeType}`) || + (calleeTypeBase && (AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType).endsWith(`.${calleeTypeBase}`))) || tspec.calleeType === '*') && (AstUtilSinkUtil.prettyPrint(fclos.rtype?.vagueType).replace(/"/g, '') === tspec.fsig || fclos.sid === tspec.fsig) @@ -121,6 +130,10 @@ function matchSinkAtFuncCallWithCalleeType( AstUtilSinkUtil.prettyPrint(fclos.object?.rtype).endsWith(`.${tspec.calleeType}`) || AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType) === tspec.calleeType || AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType).endsWith(`.${tspec.calleeType}`) || + (calleeTypeBase && (AstUtilSinkUtil.prettyPrint(fclos.object?.rtype) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.object?.rtype).endsWith(`.${calleeTypeBase}`) || + AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.object?.rtype?.definiteType).endsWith(`.${calleeTypeBase}`))) || tspec.calleeType === '*') && AstUtilSinkUtil.prettyPrint(fclos.property) === tspec.fsig ) { @@ -131,6 +144,10 @@ function matchSinkAtFuncCallWithCalleeType( AstUtilSinkUtil.prettyPrint(fclos.rtype).endsWith(`.${tspec.calleeType}`) || AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType) === tspec.calleeType || AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType).endsWith(`.${tspec.calleeType}`) || + (calleeTypeBase && (AstUtilSinkUtil.prettyPrint(fclos.rtype) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.rtype).endsWith(`.${calleeTypeBase}`) || + AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType) === calleeTypeBase || + AstUtilSinkUtil.prettyPrint(fclos.rtype?.definiteType).endsWith(`.${calleeTypeBase}`))) || tspec.calleeType === '*') && AstUtilSinkUtil.prettyPrint(fclos.ast?.node) === tspec.fsig ) { diff --git a/src/checker/taint/common-kit/source-util.ts b/src/checker/taint/common-kit/source-util.ts index 653abba1..bd664daf 100644 --- a/src/checker/taint/common-kit/source-util.ts +++ b/src/checker/taint/common-kit/source-util.ts @@ -120,14 +120,35 @@ function introduceTaintAtFuncCallReturnValue( } } +/** + * source calleeType 匹配，兼容 Go 嵌入类型 + * 优先直接匹配 scope.rtype，失败后检查 fclos._base（嵌入基类） + */ +function matchSourceCalleeType(scope: any, fclos: any, expectedType: string): boolean { + if (!expectedType || expectedType === '*') return true + + // 直接匹配（现有逻辑） + if (AstUtil.prettyPrint(scope?.rtype) === expectedType) return true + + // 嵌入类型 fallback：方法继承自基类时，检查基类 logicalQid + if (fclos?._base) { + const baseQid = fclos._base.logicalQid || fclos._base.qid || '' + const baseType = expectedType.replace(/^\*/, '') + if (baseQid === baseType || baseQid.endsWith('.' + baseType)) return true + } + + return false +} + /** * * @param scope * @param node * @param callInfo * @param funcCallArgTaintSource + * @param fclos */ -function introduceFuncArgTaintByRuleConfig(scope: any, node: any, callInfo: CallInfo | undefined, funcCallArgTaintSource: any): void { +function introduceFuncArgTaintByRuleConfig(scope: any, node: any, callInfo: CallInfo | undefined, funcCallArgTaintSource: any, fclos?: any): void { if (!BasicRuleHandler.getPreprocessReady()) { return } @@ -142,7 +163,7 @@ function introduceFuncArgTaintByRuleConfig(scope: any, node: any, callInfo: Call if ( (matchField(call.callee?.property, marray, marray.length - 1) || matchField(call.callee, marray, marray.length - 1)) && - (AstUtil.prettyPrint(scope?.rtype) === tspec.calleeType || tspec.calleeType === '*') + matchSourceCalleeType(scope, fclos, tspec.calleeType) ) { const args = prepareArgs(callInfo, undefined, tspec) for (let i = 0; i < args.length; i++) { @@ -215,6 +236,15 @@ function introduceTaintAtIdentifier(analyzer: any, scope: any, node: any, res: a if (!isGlobalIdentifierSource && kinds.some((k: string) => target.taint?.containsTag(k))) { continue } + // 函数参数（entrypoint）：作用域在当前函数，不需要 clone，保持 entrypoint SOURCE + // 全局变量：需要 clone + 重新标记，让每条路径有独立的 SOURCE 位置 + if (isGlobalIdentifierSource && alreadyTainted && kinds.some((k: string) => target.taint?.containsTag(k))) { + const params = scope.ast?.fdef?.parameters + const isFuncParam = Array.isArray(params) && params.some((p: any) => p.name === node.name) + if (isFuncParam) { + continue + } + } if (alreadyTainted && target === res && isGlobalIdentifierSource) { target = buildNewValueInstance( analyzer, diff --git a/src/checker/taint/common-kit/taint-finding-util.ts b/src/checker/taint/common-kit/taint-finding-util.ts index dfde9109..8558a17a 100644 --- a/src/checker/taint/common-kit/taint-finding-util.ts +++ b/src/checker/taint/common-kit/taint-finding-util.ts @@ -42,8 +42,8 @@ function outputCheckerResultToConsole(findings: TaintFinding[], printf: PrintFun if (typeof finding.sinkRule !== 'undefined' && finding.sinkRule !== 'Default') { printf('SINK RULE:', finding.sinkRule) } - if (finding.sinkAttribute) { - printf('SINK Attribute:', finding.sinkAttribute) + if (finding.sinkAttribute && finding.sinkAttribute.length > 0) { + printf('SINK Attribute:', finding.sinkAttribute.join(',')) } // the entrypoint of this source if (entrypoint && entrypoint.filepath !== Constant.YASA_DEFAULT) { diff --git a/src/checker/taint/go/beego-entrypoint-collect-checker.ts b/src/checker/taint/go/beego-entrypoint-collect-checker.ts index 1ea87a7e..31fa3295 100644 --- a/src/checker/taint/go/beego-entrypoint-collect-checker.ts +++ b/src/checker/taint/go/beego-entrypoint-collect-checker.ts @@ -275,7 +275,7 @@ class BeegoEntrypointCollectChecker extends Checker { const hash = JSON.stringify(controllerMethodVal.ast.node.loc) if (!processedRouteRegistry.has(hash)) { processedRouteRegistry.add(hash) - if (controllerMethodVal._this?._qid) controllerQids.add(controllerMethodVal._this._qid) + controllerQids.add(controllerMethodVal._this?._qid ?? '') const entryPoint = completeEntryPoint(controllerMethodVal) analyzer.entryPoints.push(entryPoint) } @@ -354,7 +354,7 @@ class BeegoEntrypointCollectChecker extends Checker { const hash = JSON.stringify(controllerMethodVal.ast.node.loc) if (!processedRouteRegistry.has(hash)) { processedRouteRegistry.add(hash) - if (controllerMethodVal._this?._qid) controllerQids.add(controllerMethodVal._this._qid) + controllerQids.add(controllerMethodVal._this?._qid ?? '') const entryPoint = completeEntryPoint(controllerMethodVal) analyzer.entryPoints.push(entryPoint) } @@ -377,7 +377,7 @@ class BeegoEntrypointCollectChecker extends Checker { const hash = JSON.stringify(controllerMethodVal.ast.node.loc) if (!processedRouteRegistry.has(hash)) { processedRouteRegistry.add(hash) - if (controllerMethodVal._this?._qid) controllerQids.add(controllerMethodVal._this._qid) + controllerQids.add(controllerMethodVal._this?._qid ?? '') const entryPoint = completeEntryPoint(controllerMethodVal) analyzer.entryPoints.push(entryPoint) } diff --git a/src/checker/taint/go/gin-default-taint-checker.ts b/src/checker/taint/go/gin-default-taint-checker.ts index 77149d75..c6999dfa 100644 --- a/src/checker/taint/go/gin-default-taint-checker.ts +++ b/src/checker/taint/go/gin-default-taint-checker.ts @@ -303,7 +303,8 @@ class GinDefaultTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -314,7 +315,8 @@ class GinDefaultTaintChecker extends TaintChecker { TAINT_TAG_NAME_GIN_DEFAULT, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategyGinDefault.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategyGinDefault.outputStrategyId) diff --git a/src/checker/taint/go/gin-taint-checker.ts b/src/checker/taint/go/gin-taint-checker.ts index f0829b31..5982d14b 100644 --- a/src/checker/taint/go/gin-taint-checker.ts +++ b/src/checker/taint/go/gin-taint-checker.ts @@ -126,6 +126,11 @@ class GinTaintChecker extends TaintChecker { } } + // 构建 classHierarchyMap（CHA fallback dispatch 需要） + if (Config.entryPointMode !== 'ONLY_CUSTOM' && analyzer.typeResolver?.findClassHierarchy) { + analyzer.classHierarchyMap = analyzer.typeResolver.findClassHierarchy(analyzer, null) + } + // 添加source if (Config.entryPointMode !== 'ONLY_CUSTOM') { const { TaintSource, FuncCallArgTaintSource, FuncCallReturnValueTaintSource } = @@ -203,7 +208,7 @@ class GinTaintChecker extends TaintChecker { const calleeObject = fclos.object this.checkByNameAndClassMatch(node, fclos, callInfo, scope, state) const funcCallArgTaintSource = this.checkerRuleConfigContent.sources?.FuncCallArgTaintSource - IntroduceTaint.introduceFuncArgTaintByRuleConfig(calleeObject, node, callInfo, funcCallArgTaintSource) + IntroduceTaint.introduceFuncArgTaintByRuleConfig(calleeObject, node, callInfo, funcCallArgTaintSource, fclos) if (Config.entryPointMode === 'ONLY_CUSTOM') return const argvalues = getLegacyArgValues(callInfo) @@ -262,7 +267,22 @@ class GinTaintChecker extends TaintChecker { * @param info */ triggerAtSymbolInterpretOfEntryPointAfter(analyzer: any, scope: any, node: any, state: any, info: any) { - if (info?.entryPoint.functionName === 'main') GinEntryPoint.clearProcessedRouteRegistry() + if (info?.entryPoint.functionName === 'main') { + GinEntryPoint.clearProcessedRouteRegistry() + // main 执行完后，检查是否有自动采集到的 gin 路由 entrypoint + // 若无（CLI 框架回调链导致路由注册代码不可达），使用 *gin.Context 参数签名全局搜索作为 fallback + const autoCollectedCount = analyzer.entryPoints.filter( + (ep: any) => ep.functionName !== 'main' + ).length + if (autoCollectedCount === 0) { + const { topScope } = analyzer + const fallbackEntrypoints = GinEntryPoint.getGinDefaultEntrypoint(topScope.context.packages) + if (!_.isEmpty(fallbackEntrypoints)) { + analyzer.entryPoints.push(...fallbackEntrypoints) + logger.info('[gin-taint-checker] route auto-collection found 0 routes after main, fallback to gin.Context signature scan: %d entrypoints', fallbackEntrypoints.length) + } + } + } } /** @@ -301,7 +321,8 @@ class GinTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -312,7 +333,8 @@ class GinTaintChecker extends TaintChecker { TAINT_TAG_NAME_GIN, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) diff --git a/src/checker/taint/go/go-default-taint-checker.ts b/src/checker/taint/go/go-default-taint-checker.ts index c31b5cc9..030214bd 100644 --- a/src/checker/taint/go/go-default-taint-checker.ts +++ b/src/checker/taint/go/go-default-taint-checker.ts @@ -76,6 +76,10 @@ class GoDefaultTaintChecker extends TaintChecker { // 使用callGraph边界作为entrypoint if (Config.entryPointMode !== 'ONLY_CUSTOM') { + // 始终构建 classHierarchyMap，CHA fallback dispatch 需要 + if (analyzer.typeResolver?.findClassHierarchy) { + analyzer.classHierarchyMap = analyzer.typeResolver.findClassHierarchy(analyzer, null) + } if (Config.cgAlgo === 'CHA' && analyzer.typeResolver) { FullCallGraphFileEntryPoint.makeFullCallGraphByType(analyzer, analyzer.typeResolver) } else { @@ -167,7 +171,7 @@ class GoDefaultTaintChecker extends TaintChecker { const calleeObject = fclos?.object this.checkByNameAndClassMatch(node, fclos, callInfo, scope, state) const funcCallArgTaintSource = this.checkerRuleConfigContent.sources?.FuncCallArgTaintSource - IntroduceTaint.introduceFuncArgTaintByRuleConfig(calleeObject, node, callInfo, funcCallArgTaintSource) + IntroduceTaint.introduceFuncArgTaintByRuleConfig(calleeObject, node, callInfo, funcCallArgTaintSource, fclos) } /** @@ -221,7 +225,8 @@ class GoDefaultTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = (rule as any).fsig if (typeof (rule as any).attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${(rule as any).attribute}` + const attrStr = Array.isArray((rule as any).attribute) ? (rule as any).attribute.join(',') : (rule as any).attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -232,7 +237,8 @@ class GoDefaultTaintChecker extends TaintChecker { TAINT_TAG_NAME, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue diff --git a/src/checker/taint/java/java-taint-abstract-checker.ts b/src/checker/taint/java/java-taint-abstract-checker.ts index d9e5deae..b8f6fe22 100644 --- a/src/checker/taint/java/java-taint-abstract-checker.ts +++ b/src/checker/taint/java/java-taint-abstract-checker.ts @@ -9,10 +9,12 @@ const { matchSinkAtFuncCallWithCalleeType: matchSinkAtFuncCallWithCalleeTypeJava, checkInvocationMatchSink, } = require('../common-kit/sink-util') +const { getOrBuildCallInfo: getOrBuildCallInfoJava } = require('../common-kit/call-info-util') const RulesJava = require('../../common/rules-basic-handler') const SanitizerCheckerJava = require('../../sanitizer/sanitizer-checker') const TaintOutputStrategyJava = require('../../common/output/taint-output-strategy') +const { satisfy, defaultFilter } = require('../../../util/ast-util') const Config = require('../../../config') const logger = require('../../../util/logger')(__filename) @@ -289,6 +291,21 @@ class JavaTaintAbstractChecker extends TaintCheckerJava { IntroduceTaintJava.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) } + /** + * NewExpression 构造器调用后触发 sink 匹配，语义对齐 triggerAtFunctionCallBefore。 + * 兼容 legacy payload（argvalues）：common analyzer 已传 callInfo，其它 analyzer 兜底转换。 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any) { + const { fclos } = info + const callInfo = getOrBuildCallInfoJava(info) + this.checkByNameAndClassMatch(node, fclos, callInfo, scope, state, info, analyzer) + } + /** * check if sink or not by name and class * @param node @@ -356,12 +373,50 @@ class JavaTaintAbstractChecker extends TaintCheckerJava { sanitizers ) if (ndResultWithMatchedSanitizerTagsArray) { + // precondition 检查：sink rule 声明了 preconditionIds 时，taint 上命中任一 precondition tag（OR 语义）即保留 finding + const preconditionIds: string[] | undefined = rule.preconditionIds + if (preconditionIds && preconditionIds.length > 0) { + // 从 args 的 taint flow 中收集所有 tags，用于 precondition 匹配 + const allTaintTags: unknown[] = [] + const fCollectTags = (nd: { taint?: { tags?: unknown[]; tagTraces?: Map } }): boolean => { + const tagTraceMap = nd?.taint?.tagTraces + if (!(tagTraceMap instanceof Map)) return false + return tagTraceMap.has(TAINT_TAG_NAME_JAVA) + } + const collectCallback = (nd: { taint?: { getTags?: () => unknown[] } }, _from: unknown, parentMap: WeakMap): void => { + // 收集当前 nd 及其 parent 链上所有节点的 taint tags + const parentNdList: Array<{ taint?: { getTags?: () => unknown[] } }> = [] + let currentNd: { taint?: { getTags?: () => unknown[] } } | undefined = nd + while (currentNd) { + if (parentNdList.includes(currentNd)) break + parentNdList.push(currentNd) + currentNd = parentMap.get(currentNd as object) as { taint?: { getTags?: () => unknown[] } } | undefined + } + for (const parentNd of parentNdList) { + // getTags() 返回 tagTraces 的 key 列表（含 SanitizerTag 对象） + const tags = parentNd.taint?.getTags?.() + if (tags && tags.length > 0) { + allTaintTags.push(...tags) + } + } + } + satisfy(args, fCollectTags, defaultFilter, undefined, true, 30, collectCallback) + + const matchedPreconditionTags = SanitizerCheckerJava.findMatchedPreconditionTags(preconditionIds, allTaintTags) + // 多个 preconditionIds 采用 OR 语义：任一命中即保留 finding + const matchedIds = new Set(matchedPreconditionTags.map((t: { id?: string }) => t.id)) + if (matchedIds.size === 0) { + continue + } + } + for (const ndResultWithMatchedSanitizerTags of ndResultWithMatchedSanitizerTagsArray) { const { nd } = ndResultWithMatchedSanitizerTags const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -372,7 +427,8 @@ class JavaTaintAbstractChecker extends TaintCheckerJava { TAINT_TAG_NAME_JAVA, ruleName, matchedSanitizerTags, - state.callstack + state.callstack, + state.callsites ) if (!TaintOutputStrategyJava.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategyJava.outputStrategyId) @@ -535,7 +591,8 @@ class JavaTaintAbstractChecker extends TaintCheckerJava { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -546,7 +603,8 @@ class JavaTaintAbstractChecker extends TaintCheckerJava { TAINT_TAG_NAME_JAVA, ruleName, matchedSanitizerTags, - state.callstack + state.callstack, + state.callsites ) if (!TaintOutputStrategyJava.isNewFinding(this.resultManager, taintFlowFinding)) continue diff --git a/src/checker/taint/js/egg-taint-checker.ts b/src/checker/taint/js/egg-taint-checker.ts index 63445f27..37b47a52 100644 --- a/src/checker/taint/js/egg-taint-checker.ts +++ b/src/checker/taint/js/egg-taint-checker.ts @@ -9,6 +9,7 @@ const Constant = require('../../../util/constant') const CommonUtil = require('../../../util/common-util') const Loader = require('../../../util/loader') const { matchSinkAtFuncCall } = require('../common-kit/sink-util') +const { getOrBuildCallInfo: getOrBuildCallInfoEgg } = require('../common-kit/call-info-util') const Config = require('../../../config') const eggHttpEgg = require('../../../engine/analyzer/javascript/egg/entrypoint-collector/egg-http') const SanitizerCheckerEgg = require('../../sanitizer/sanitizer-checker') @@ -245,6 +246,24 @@ class EggTaintChecker extends TaintCheckerEgg { IntroduceTaint.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) } + /** + * NewExpression 构造器调用后触发 sink 匹配，语义对齐 triggerAtFunctionCallBefore。 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any) { + if (Config.analyzer !== 'EggAnalyzer') { + return + } + const { fclos } = info + const callInfo = getOrBuildCallInfoEgg(info) + this.checkSinkAtFunctionCall(node, fclos, callInfo, state) + this.checkByFieldMatch(node, fclos, callInfo, scope, state) + } + /** * * @param analyzer @@ -294,7 +313,8 @@ class EggTaintChecker extends TaintCheckerEgg { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -305,7 +325,8 @@ class EggTaintChecker extends TaintCheckerEgg { TAINT_TAG_NAME_EGG, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategyEgg.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategyEgg.outputStrategyId) @@ -369,8 +390,7 @@ class EggTaintChecker extends TaintCheckerEgg { CallObj = CallFull.substring(0, lastIndexofCall) } if (CallObj !== RuleObj) { - const idx = CallObj.lastIndexOf('(') - const result = idx !== -1 ? CallObj.slice(0, idx) : CallObj + const result = QidUnifyUtil.removeParenthesesFromString(CallObj) if (result !== RuleObj) { if (!result.endsWith(`.${RuleObj}`) && !result.startsWith(`${RuleObj}.`)) { return false @@ -407,7 +427,8 @@ class EggTaintChecker extends TaintCheckerEgg { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\n` + `SINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\n` + `SINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -418,7 +439,8 @@ class EggTaintChecker extends TaintCheckerEgg { TAINT_TAG_NAME_EGG, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategyEgg.isNewFinding(this.resultManager, taintFlowFinding)) continue diff --git a/src/checker/taint/js/express/express-taint-checker.ts b/src/checker/taint/js/express/express-taint-checker.ts index b80f9b93..8a200507 100644 --- a/src/checker/taint/js/express/express-taint-checker.ts +++ b/src/checker/taint/js/express/express-taint-checker.ts @@ -10,6 +10,7 @@ const constValue = require('../../../../util/constant') const commonUtil = require('../../../../util/common-util') const loader = require('../../../../util/loader') const { matchSinkAtFuncCall } = require('../../common-kit/sink-util') +const { getOrBuildCallInfo } = require('../../common-kit/call-info-util') const TaintChecker = require('../../taint-checker') const config = require('../../../../config') const SanitizerChecker = require('../../../sanitizer/sanitizer-checker') @@ -202,6 +203,24 @@ class ExpressTaintChecker extends TaintChecker { IntroduceTaint.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) } + /** + * NewExpression 构造器调用后触发 sink 匹配，语义对齐 triggerAtFunctionCallBefore。 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any) { + if (config.analyzer !== 'JavaScriptAnalyzer') { + return + } + const { fclos } = info + const callInfo = getOrBuildCallInfo(info) + this.checkSinkAtFunctionCall(node, fclos, callInfo, state) + this.checkByFieldMatch(node, fclos, callInfo, scope, state) + } + /** * * @param analyzer @@ -251,7 +270,8 @@ class ExpressTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -262,7 +282,8 @@ class ExpressTaintChecker extends TaintChecker { TAINT_TAG_NAME, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) @@ -327,8 +348,7 @@ class ExpressTaintChecker extends TaintChecker { CallObj = CallFull.substring(0, lastIndexofCall) } if (CallObj !== RuleObj) { - const idx = CallObj.lastIndexOf('(') - const result = idx !== -1 ? CallObj.slice(0, idx) : CallObj + const result = QidUnifyUtil.removeParenthesesFromString(CallObj) if (result !== RuleObj) { if (!result.endsWith(`.${RuleObj}`) && !result.startsWith(`${RuleObj}.`)) { return false @@ -365,7 +385,8 @@ class ExpressTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\n` + `SINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\n` + `SINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -376,7 +397,8 @@ class ExpressTaintChecker extends TaintChecker { TAINT_TAG_NAME, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue diff --git a/src/checker/taint/js/js-taint-checker.ts b/src/checker/taint/js/js-taint-checker.ts index face6f97..100648c6 100644 --- a/src/checker/taint/js/js-taint-checker.ts +++ b/src/checker/taint/js/js-taint-checker.ts @@ -10,6 +10,7 @@ const constValue = require('../../../util/constant') const commonUtil = require('../../../util/common-util') const loader = require('../../../util/loader') const { matchSinkAtFuncCall } = require('../common-kit/sink-util') +const { getOrBuildCallInfo } = require('../common-kit/call-info-util') const QidUnifyUtil = require('../../../util/qid-unify-util') const TaintChecker = require('../taint-checker') const config = require('../../../config') @@ -210,6 +211,24 @@ class JsTaintChecker extends TaintChecker { IntroduceTaint.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) } + /** + * NewExpression 构造器调用后触发 sink 匹配，语义对齐 triggerAtFunctionCallBefore。 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any) { + if (config.analyzer !== 'JavaScriptAnalyzer') { + return + } + const { fclos } = info + const callInfo = getOrBuildCallInfo(info) + this.checkSinkAtFunctionCall(node, fclos, callInfo, state) + this.checkByFieldMatch(node, fclos, callInfo, scope, state) + } + /** * * @param analyzer @@ -259,7 +278,8 @@ class JsTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -270,7 +290,8 @@ class JsTaintChecker extends TaintChecker { TAINT_TAG_NAME_JS_TAINT, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) @@ -334,8 +355,7 @@ class JsTaintChecker extends TaintChecker { CallObj = CallFull.substring(0, lastIndexofCall) } if (CallObj !== RuleObj) { - const idx = CallObj.lastIndexOf('(') - const result = idx !== -1 ? CallObj.slice(0, idx) : CallObj + const result = QidUnifyUtil.removeParenthesesFromString(CallObj) if (result !== RuleObj) { if (!result.endsWith(`.${RuleObj}`) && !result.startsWith(`${RuleObj}.`)) { return false @@ -372,7 +392,8 @@ class JsTaintChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\n` + `SINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\n` + `SINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -383,7 +404,8 @@ class JsTaintChecker extends TaintChecker { TAINT_TAG_NAME_JS_TAINT, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue diff --git a/src/checker/taint/php/php-default-taint-checker.ts b/src/checker/taint/php/php-default-taint-checker.ts new file mode 100644 index 00000000..a225ce95 --- /dev/null +++ b/src/checker/taint/php/php-default-taint-checker.ts @@ -0,0 +1,352 @@ +import type { CallInfo } from '../../../engine/analyzer/common/call-args' + +const _ = require('lodash') +const Config = require('../../../config') +const BasicRuleHandler = require('../../common/rules-basic-handler') +const AstUtil = require('../../../util/ast-util') +const FileUtil = require('../../../util/file-util') +const EntryPoint = require('../../../engine/analyzer/common/entrypoint') +const Constant = require('../../../util/constant') +const IntroduceTaint = require('../common-kit/source-util') +const { matchSinkAtFuncCallWithCalleeType } = require('../common-kit/sink-util') +const { getOrBuildCallInfo } = require('../common-kit/call-info-util') +const SanitizerChecker = require('../../sanitizer/sanitizer-checker') +const FullCallGraphFileEntryPoint = require('../../common/full-callgraph-file-entrypoint') +const CommonUtil = require('../../../util/common-util') +const TaintChecker = require('../taint-checker') +const { + findSpartaEntryPoints, +} = require('../../../engine/analyzer/php/sparta/entrypoint-collector/sparta-default-entrypoint') +const { + findSoaServiceEntryPoints, +} = require('../../../engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint') +const { + findHaodfMvcControllerEntryPoints, +} = require('../../../engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint') +const { + findHaodfDataBucketEntryPoints, +} = require('../../../engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint') +const TaintOutputStrategy = require('../../common/output/taint-output-strategy') +const entryPointConfig = require('../../../engine/analyzer/common/current-entrypoint') + +const TAINT_TAG_NAME = 'PHP_INPUT' + +/** + * PHP 默认污点分析 checker，使用 CallGraph 边界 + 文件级 entrypoint + */ +class PhpDefaultTaintChecker extends TaintChecker { + entryPoints: any[] + + /** + * @param resultManager + */ + constructor(resultManager: any) { + super(resultManager, 'taint_flow_php_input') + this.entryPoints = [] + } + + /** + * 分析开始时加载 entrypoint 并标记 source scope + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtStartOfAnalyze(analyzer: any, scope: any, node: any, state: any, info: any): void { + this.prepareEntryPoints(analyzer) + analyzer.mainEntryPoints = this.entryPoints + this.addSourceTagForSourceScope(TAINT_TAG_NAME, this.sourceScope.value) + this.addSourceTagForcheckerRuleConfigContent(TAINT_TAG_NAME, this.checkerRuleConfigContent) + // PHP 超全局变量 source 需要带 loc 信息初始化 + CommonUtil.initSourceScopeByTaintSourceWithLoc(this.sourceScope, this.checkerRuleConfigContent.sources?.TaintSource) + } + + /** + * 准备 entrypoint：callGraph 边界 + 文件级 + ruleconfig 自定义 + * @param analyzer + */ + prepareEntryPoints(analyzer: any): void { + if (Config.entryPointMode === 'ONLY_CUSTOM') { + this.prepareRuleConfigEntryPoints(analyzer) + return + } + + // 优先：Sparta 框架 Controller action entrypoint + const spartaEntryPoints = findSpartaEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + if (spartaEntryPoints.length > 0) { + // 框架 entrypoints 需要解析 symVal，复用 ruleconfig entrypoint 的解析逻辑 + this.resolveFrameworkEntryPoints(analyzer, spartaEntryPoints) + } + + // SOA Service entrypoint：类名以 Svc/Service 结尾的服务类方法 + // SOA collector 直接返回带 symVal 的完整 EntryPoint（PHP 类方法 fclos 不在 context.funcs 中） + if (this.entryPoints.length === 0) { + const soaEntryPoints = findSoaServiceEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + if (soaEntryPoints.length > 0) { + this.entryPoints.push(...soaEntryPoints) + } + } + + // Haodf 自研 MVC（avatar 桶）：基于类签名约定识别 + // - HaodfMvcController：controllers/ 下 Controller 后缀/继承 + public + params>=1 action + // - HaodfDataBucket：mobileapi/weixmpapi/wap 的 DataBucket 后缀/继承 + public + params>=1 + // 两者合并 append（单个项目可能同时出现两类，如 wap 既有 Controller 又有 mobileapi/ 子目录 DataBucket） + if (this.entryPoints.length === 0) { + const mvcEntryPoints = findHaodfMvcControllerEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + if (mvcEntryPoints.length > 0) { + this.entryPoints.push(...mvcEntryPoints) + } + const dataBucketEntryPoints = findHaodfDataBucketEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + if (dataBucketEntryPoints.length > 0) { + this.entryPoints.push(...dataBucketEntryPoints) + } + } + + // 兜底：callGraph 边界 + 文件级 entrypoint（仅在没有框架 entrypoint 时使用） + // if (this.entryPoints.length === 0) { + // FullCallGraphFileEntryPoint.makeFullCallGraph(analyzer) + // const fullCallGraphEntrypoint = FullCallGraphFileEntryPoint.getAllEntryPointsUsingCallGraph( + // analyzer.ainfo?.callgraph, + // analyzer + // ) + // this.entryPoints.push(...fullCallGraphEntrypoint) + // + // const fullFileEntrypoint = FullCallGraphFileEntryPoint.getAllFileEntryPointsUsingFileManager(analyzer) + // this.entryPoints.push(...fullFileEntrypoint) + // } + + // ruleconfig 中的自定义 entrypoint + if (Config.entryPointMode !== 'SELF_COLLECT') { + this.prepareRuleConfigEntryPoints(analyzer) + } + } + + /** + * 加载 ruleconfig 中指定的 entrypoint + * @param analyzer + */ + prepareRuleConfigEntryPoints(analyzer: any): void { + const { entrypoints: ruleConfigEntryPoints } = this.checkerRuleConfigContent + if (_.isEmpty(ruleConfigEntryPoints)) return + + const { topScope } = analyzer + for (const entrypoint of ruleConfigEntryPoints) { + // PHP 函数是全局的，无包前缀，直接用函数名匹配 + const entryPointSymVal = AstUtil.satisfy( + topScope.context.packages || topScope.context.funcs, + (n: any) => + n.vtype === 'fclos' && + FileUtil.extractAfterSubstring(n?.ast?.node?.loc?.sourcefile, Config.maindirPrefix) === entrypoint.filePath && + n?.ast?.node?.id?.name === entrypoint.functionName, + (node: any, prop: any) => prop === '_field', + null, + false + ) + + if (_.isEmpty(entryPointSymVal)) continue + + const symVals = Array.isArray(entryPointSymVal) + ? _.uniqBy(entryPointSymVal, (value: any) => value.ast.fdef) + : [entryPointSymVal] + + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = symVals[0].parent + ep.argValues = [] + ep.functionName = entrypoint.functionName + ep.filePath = entrypoint.filePath + ep.attribute = entrypoint.attribute + ep.packageName = undefined + ep.entryPointSymVal = symVals[0] + analyzer.ruleEntrypoints = analyzer.ruleEntrypoints || [] + analyzer.ruleEntrypoints.push(ep) + } + } + + /** + * 解析框架 entrypoint 的 symVal（函数 scope value） + * 框架 entrypoint collector 只收集 filePath + functionName 元数据， + * 这里通过 AST 查找将其解析为完整的 entrypoint（带 scopeVal + entryPointSymVal） + * @param analyzer + * @param frameworkEntryPoints + */ + resolveFrameworkEntryPoints(analyzer: any, frameworkEntryPoints: any[]): void { + const { topScope } = analyzer + for (const fep of frameworkEntryPoints) { + const entryPointSymVal = AstUtil.satisfy( + topScope.context.packages || topScope.context.funcs, + (n: any) => + n.vtype === 'fclos' && + FileUtil.extractAfterSubstring(n?.ast?.node?.loc?.sourcefile, Config.maindirPrefix) === fep.filePath && + n?.ast?.node?.id?.name === fep.functionName, + (n: any, prop: any) => prop === '_field', + null, + false + ) + + if (_.isEmpty(entryPointSymVal)) continue + + const symVals = Array.isArray(entryPointSymVal) + ? _.uniqBy(entryPointSymVal, (value: any) => value.ast?.fdef) + : [entryPointSymVal] + + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = symVals[0].parent + ep.argValues = [] + ep.functionName = fep.functionName + ep.filePath = fep.filePath + ep.attribute = fep.attribute || 'SpartaHTTP' + ep.entryPointSymVal = symVals[0] + this.entryPoints.push(ep) + } + } + + /** + * 函数调用前：匹配 sink，引入 FuncCallArgTaintSource + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtFunctionCallBefore(analyzer: any, scope: any, node: any, state: any, info: any): void { + const { fclos, callInfo } = info + const calleeObject = fclos?.object + this.checkByNameAndClassMatch(node, fclos, callInfo, scope, state) + const funcCallArgTaintSource = this.checkerRuleConfigContent.sources?.FuncCallArgTaintSource + IntroduceTaint.introduceFuncArgTaintByRuleConfig(calleeObject, node, callInfo, funcCallArgTaintSource) + } + + /** + * 函数调用后：处理返回值 source（如 file_get_contents 等） + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtFunctionCallAfter(analyzer: any, scope: any, node: any, state: any, info: any): void { + const { fclos, ret } = info + const funcCallReturnValueTaintSource = this.checkerRuleConfigContent.sources?.FuncCallReturnValueTaintSource + IntroduceTaint.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) + } + + /** + * NewExpression 构造器调用后触发 sink 匹配，语义对齐 triggerAtFunctionCallBefore。 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtNewExprAfter(analyzer: any, scope: any, node: any, state: any, info: any): void { + const { fclos } = info + const callInfo = getOrBuildCallInfo(info) + this.checkByNameAndClassMatch(node, fclos, callInfo, scope, state) + } + + /** + * sink 匹配：按函数名和 calleeType 匹配 + * @param node + * @param fclos + * @param callInfo + * @param scope + * @param state + */ + checkByNameAndClassMatch( + node: any, + fclos: any, + callInfo: CallInfo | undefined, + scope: any, + state?: any + ): boolean | undefined { + if (fclos === undefined) return + const rules = this.checkerRuleConfigContent.sinks?.FuncCallTaintSink + if (!rules || !callInfo) return + + let rule = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, scope, callInfo) + rule = rule.length > 0 ? rule[0] : null + if (!rule) return + + const args = BasicRuleHandler.prepareArgs(callInfo, fclos, rule) + const sanitizers = SanitizerChecker.findSanitizerByIds((rule as any).sanitizerIds) + const ndResultWithMatchedSanitizerTagsArray = SanitizerChecker.findTagAndMatchedSanitizer( + node, + fclos, + args, + scope, + TAINT_TAG_NAME, + true, + sanitizers + ) + + if (!ndResultWithMatchedSanitizerTagsArray) return + + for (const ndResultWithMatchedSanitizerTags of ndResultWithMatchedSanitizerTagsArray) { + const { nd, matchedSanitizerTags } = ndResultWithMatchedSanitizerTags + let ruleName = (rule as any).fsig + if (typeof (rule as any).attribute !== 'undefined') { + const attrStr = Array.isArray((rule as any).attribute) + ? (rule as any).attribute.join(',') + : (rule as any).attribute + ruleName += `\nSINK Attribute: ${attrStr}` + } + + const taintFlowFinding = this.buildTaintFinding( + this.getCheckerId(), + this.desc, + node, + nd, + fclos, + TAINT_TAG_NAME, + ruleName, + matchedSanitizerTags, + state?.callstack, + state?.callsites + ) + + if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue + this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) + } + return true + } + + /** + * Entrypoint 参数 taint 注入：所有 PHP entrypoint 的入参统一全部标 source + * - SOAService / HaodfDataBucket / HaodfMvcController：所有参数都视为外部输入 + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtSymbolInterpretOfEntryPointBefore(analyzer: any, scope: any, node: any, state: any, info: any): void { + const currentEntryPoint = entryPointConfig.getCurrentEntryPoint() + const attr = currentEntryPoint?.attribute + const TAINT_ATTRS = new Set(['SOAService', 'HaodfDataBucket', 'HaodfMvcController']) + if (!TAINT_ATTRS.has(attr)) return + const epSym = currentEntryPoint.entryPointSymVal + const parameters = epSym?.ast?.fdef?.parameters + if (!parameters) return + for (const para of parameters) { + // 使用 para.id（Identifier）而非 para（VariableDeclaration），避免 processInstruction 重建值 + const paramId = para.id || para + const argv = analyzer.processInstruction(epSym, paramId, state) + IntroduceTaint.markTaintSource(argv, { path: para, kind: TAINT_TAG_NAME }) + } + } + + /** + * Identifier 触发：标记超全局变量等 source + * @param analyzer + * @param scope + * @param node + * @param state + * @param info + */ + triggerAtIdentifier(analyzer: any, scope: any, node: any, state: any, info: any): void { + IntroduceTaint.introduceTaintAtIdentifierDirect(analyzer, scope, node, info.res, this.sourceScope.value) + } +} + +module.exports = PhpDefaultTaintChecker diff --git a/src/checker/taint/python/django-taint-checker.ts b/src/checker/taint/python/django-taint-checker.ts index cebf58c2..102db461 100644 --- a/src/checker/taint/python/django-taint-checker.ts +++ b/src/checker/taint/python/django-taint-checker.ts @@ -4,6 +4,8 @@ const { extractRelativePath } = require('../../../util/file-util') const AstUtil = require('../../../util/ast-util') const Config = require('../../../config') +const path = require('path') +const { resolveImportPath } = require('../../../engine/analyzer/python/common/python-import-resolver') interface ASTObject { body?: any[] @@ -11,12 +13,45 @@ interface ASTObject { [key: string]: any } +/** 待延迟处理的 include() 调用信息 */ +interface PendingInclude { + includeCall: ASTObject + analyzer: ASTObject + state: ASTObject +} + +/** 待延迟处理的视图函数（processInstruction 返回 symbol 而非 fclos） */ +interface PendingView { + analyzer: any + scope: any + state: any + viewFunction: ASTObject + targetSrcName: string[] +} + +/** ValueRefMap 的接口子集，用于 modules.members */ +interface ModuleMembers { + get(key: string): ASTObject | null + keys(): IterableIterator + entries(): [string, ASTObject][] + size: number +} + const registerFile = new Set() /** * Django entrypoint采集以及框架source添加 */ class DjangoTaintChecker extends PythonTaintAbstractChecker { + /** 延迟处理的 include() 调用列表，随文件逐个加载逐步清空 */ + private pendingIncludes: PendingInclude[] = [] + + /** 延迟处理的视图函数列表，等待模块加载后重新解析 */ + private pendingViews: PendingView[] = [] + + /** 循环引用防护：已访问的 include 文件路径集合 */ + private visitedFiles: Set = new Set() + /** * constructor * @param resultManager @@ -71,14 +106,187 @@ class DjangoTaintChecker extends PythonTaintAbstractChecker { } } + /** + * 每个文件处理完后尝试解析待处理的 include() 和未解析的视图函数 + * 随着文件逐个加载，目标模块的 scope 逐渐可用，pending 队列逐步清空 + * 确保 entrypoints 在 symbolInterpret 之前全部注册 + */ + triggerAtEndOfCompileUnit(analyzer: any, scope: any, node: any, state: any, info: any): void { + // 处理待解析的 include() + if (this.pendingIncludes.length > 0) { + const stillPendingIncludes: PendingInclude[] = [] + + for (const pending of this.pendingIncludes) { + const resolved = this.tryResolveInclude( + pending.analyzer as any, + pending.state as any, + pending.includeCall + ) + if (!resolved) { + stillPendingIncludes.push(pending) + } + } + + this.pendingIncludes = stillPendingIncludes + } + + // 处理待解析的视图函数（模块加载后重新解析 MemberAccess 引用） + if (this.pendingViews.length > 0) { + const stillPendingViews: PendingView[] = [] + + for (const pending of this.pendingViews) { + const resolved = this.tryResolvePendingView(pending) + if (!resolved) { + stillPendingViews.push(pending) + } + } + + this.pendingViews = stillPendingViews + } + } + + /** + * 尝试解析待处理的视图函数 + * 重新调用 processInstruction，若目标模块已加载则返回 fclos + */ + private tryResolvePendingView(pending: PendingView): boolean { + const { analyzer, scope, state, viewFunction, targetSrcName } = pending + const ep = analyzer.processInstruction(scope, viewFunction, state) + if (ep.vtype === 'fclos') { + this.registerFuncViewEntrypoint(analyzer, ep, targetSrcName) + return true + } + // processInstruction 仍返回 symbol，尝试从已加载模块中直接查找函数定义 + if (ep.vtype === 'symbol' && viewFunction.type === 'MemberAccess') { + const funcName: string | undefined = viewFunction.property?.name + const moduleName: string | undefined = viewFunction.object?.name + if (!funcName || !moduleName) return false + + const resolved = this.resolveViewFromModules(analyzer, scope, state, moduleName, funcName) + if (resolved) { + this.registerFuncViewEntrypoint(analyzer, resolved, targetSrcName) + return true + } + } + return false + } + + /** + * 从已加载的模块 scope 中查找视图函数的 fclos 值 + * 处理 MemberAccess 形式（如 views.api_pipeline_detail）在模块尚未完全解析时的情况 + */ + private resolveViewFromModules( + analyzer: any, + scope: any, + state: any, + moduleName: string, + funcName: string + ): any | null { + // 从 scope 中获取模块引用 + const moduleVal = scope?.value?.[moduleName] + if (!moduleVal) return null + + // 如果模块已解析，直接从 value 中获取函数 + const funcVal = moduleVal.value?.[funcName] + if (funcVal?.vtype === 'fclos') return funcVal + + // 回退：遍历已加载模块的 members，查找匹配文件中的函数定义 + const members: ModuleMembers | undefined = + analyzer.topScope?.context?.modules?.members + if (!members) return null + + for (const [filePath, moduleScope] of members.entries()) { + // 匹配模块名：import views from demoapp → 查找 demoapp 目录下的 views.py + if (!filePath.endsWith('/views.py') && !filePath.endsWith('/' + moduleName + '.py')) continue + + const scopeValue = (moduleScope as any)?.value + if (!scopeValue) continue + + const targetFunc = scopeValue[funcName] + if (targetFunc?.vtype === 'fclos') return targetFunc + } + + return null + } + + /** + * 尝试解析单个 include()，成功返回 true，目标模块尚未加载时返回 false + * 目录级 include 会在每轮 endOfCompileUnit 重新扫描，捕获新加载的文件 + */ + private tryResolveInclude( + analyzer: any, + state: any, + includeCall: ASTObject + ): boolean { + if (!includeCall.arguments || includeCall.arguments.length < 1) return true + + const firstArg = includeCall.arguments[0] + if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') return true + + const modulePath: string = firstArg.value + const currentFile: string | undefined = includeCall.loc?.sourcefile + if (!currentFile || !analyzer.fileList) return true + + const resolvedPath: string | null = resolveImportPath( + modulePath, + currentFile, + analyzer.fileList, + Config.maindir + ) + if (!resolvedPath) return true + + const isDirectFile: boolean = resolvedPath.endsWith('.py') + + // 单文件 include：已处理则跳过 + if (isDirectFile && this.visitedFiles.has(resolvedPath)) return true + + const members: ModuleMembers | undefined = + analyzer.topScope?.context?.modules?.members + if (!members) return false + + const moduleScopes: Array<{ scope: ASTObject; filePath: string }> = + this.resolveModuleScopes(resolvedPath, members) + + // 目标模块尚未加载，保留在 pending 列表 + if (moduleScopes.length === 0) return false + + // 过滤出尚未处理的新文件 + const newScopes: Array<{ scope: ASTObject; filePath: string }> = + moduleScopes.filter(s => !this.visitedFiles.has(s.filePath)) + + // 处理新文件 + for (const { scope, filePath } of newScopes) { + this.visitedFiles.add(filePath) + this.collectUrlpatternsFromScope(analyzer, scope, state, this.visitedFiles) + } + + // 单文件 include：标记并完成 + if (isDirectFile) { + this.visitedFiles.add(resolvedPath) + return true + } + + // 目录级 include：始终保持 pending，因为后续可能有更多文件加载 + // 开销极低：每轮只做 members 遍历 + visitedFiles 过滤 + return false + } + /** * * @param analyzer * @param scope * @param state * @param value + * @param visitedFiles - 已访问的 include 文件路径集合，用于防止循环引用 */ - collectDjangoEntrypointAndSource(analyzer: any, scope: any, state: any, value: any) { + collectDjangoEntrypointAndSource( + analyzer: any, + scope: any, + state: any, + value: any, + visitedFiles?: Set + ) { + const visited = visitedFiles || new Set() const elementGroups: any[] = [] this.extractElementsFromNode(elementGroups, value) @@ -95,17 +303,30 @@ class DjangoTaintChecker extends PythonTaintAbstractChecker { if (methodName !== 'path' && methodName !== 're_path' && methodName !== 'url') { continue } - // 获取path调用的参数 - if (element.arguments && element.arguments.length >= 2) { - const targetSrcName = this.extractParamNames(element.arguments[0].value) - const viewFunction = element.arguments[1] - if (viewFunction.type === 'Identifier' || viewFunction.type === 'MemberAccess') { - this.collectFuncViewEntrypointAndSource(analyzer, scope, state, viewFunction, targetSrcName) - } else if (viewFunction.type === 'CallExpression' && viewFunction.callee) { - // include的情况暂时不用支持，因为最终路由的entrypoint最终也会在另一个文件中完成采集 - if (viewFunction.callee.type === 'MemberAccess' && viewFunction.callee.property.name === 'as_view') { - this.collectClassViewEntrypointAndSource(analyzer, scope, state, viewFunction, targetSrcName) - } + // 获取 path() 调用的参数，支持位置参数和关键字参数 + const args: ASTObject[] = element.arguments || [] + if (args.length < 2) continue + + const { routeArg, viewArg } = this.extractPathArgs(args) + if (!viewArg) continue + + const routeValue: string = routeArg?.value ?? routeArg?.init?.value ?? '' + const targetSrcName = this.extractParamNames(routeValue) + const viewFunction: ASTObject = viewArg + + if (viewFunction.type === 'Identifier' || viewFunction.type === 'MemberAccess') { + this.collectFuncViewEntrypointAndSource(analyzer, scope, state, viewFunction, targetSrcName) + } else if (viewFunction.type === 'CallExpression' && viewFunction.callee) { + const viewCallName = this.extractCallName(viewFunction.callee) + if (viewCallName === 'as_view') { + this.collectClassViewEntrypointAndSource(analyzer, scope, state, viewFunction, targetSrcName) + } else if (viewCallName === 'include') { + // include() 延迟到 endOfCompileUnit 逐步处理，等待目标模块加载 + this.pendingIncludes.push({ + includeCall: viewFunction, + analyzer: analyzer, + state: state, + }) } } } @@ -113,12 +334,135 @@ class DjangoTaintChecker extends PythonTaintAbstractChecker { } /** - * - * @param analyzer - * @param scope - * @param state - * @param viewFunction - * @param targetSrcName + * 从 path()/re_path()/url() 调用中提取 route 和 view 参数 + * 支持位置参数和关键字参数（VariableDeclaration）两种形式 + */ + extractPathArgs(args: ASTObject[]): { routeArg: ASTObject | null; viewArg: ASTObject | null } { + const isKeywordArg = (arg: ASTObject): boolean => + arg.type === 'VariableDeclaration' && !!arg.id?.name + + if (args.length >= 2 && !isKeywordArg(args[0])) { + // 位置参数形式：path('route/', view_func) + return { routeArg: args[0], viewArg: args[1] } + } + + // 关键字参数形式：path(route='...', view=view_func) + let routeArg: ASTObject | null = null + let viewArg: ASTObject | null = null + for (const arg of args) { + if (!isKeywordArg(arg)) continue + const keyName: string = arg.id.name + if (keyName === 'route' || keyName === 'regex' || keyName === 'pattern') { + routeArg = arg.init || null + } else if (keyName === 'view') { + viewArg = arg.init || null + } + } + return { routeArg, viewArg } + } + + /** + * 从 CallExpression 的 callee 节点中提取方法名 + */ + extractCallName(callee: ASTObject): string | null { + if (callee.type === 'MemberAccess' && callee.property?.name) { + return callee.property.name + } + if (callee.type === 'Identifier') { + return callee.name || null + } + return null + } + + /** + * 根据解析路径查找所有相关的模块 scope + * 处理两种情况：直接文件匹配 和 包目录（含 __init__.py） + * 当 __init__.py 无有效 urlpatterns 时，回退扫描同目录 *_urls.py 文件 + */ + resolveModuleScopes( + resolvedPath: string, + members: ModuleMembers + ): Array<{ scope: ASTObject; filePath: string }> { + const results: Array<{ scope: ASTObject; filePath: string }> = [] + const normalizedResolved: string = path.normalize(resolvedPath) + + // 直接匹配：resolvedPath 本身（.py 文件的情况） + const directScope: ASTObject | null = members.get(normalizedResolved) + if (directScope) { + results.push({ scope: directScope, filePath: normalizedResolved }) + return results + } + + // 包目录匹配：resolvedPath 是目录时，查找 __init__.py + const initFilePath: string = path.normalize( + path.join(normalizedResolved, '__init__.py') + ) + const initScope: ASTObject | null = members.get(initFilePath) + if (initScope) { + const hasUrlpatterns: boolean = this.scopeHasUrlpatterns(initScope) + if (hasUrlpatterns) { + results.push({ scope: initScope, filePath: initFilePath }) + return results + } + } + + // exec() 动态加载的 fallback：__init__.py 无有效 urlpatterns，扫描同目录 *_urls.py 文件 + const dirPrefix: string = normalizedResolved + path.sep + for (const [filePath, scope] of members.entries()) { + const normalizedFilePath: string = path.normalize(filePath) + const baseName: string = path.basename(normalizedFilePath) + if ( + normalizedFilePath.startsWith(dirPrefix) && + baseName.endsWith('_urls.py') + ) { + results.push({ scope: scope as ASTObject, filePath: normalizedFilePath }) + } + } + + return results + } + + /** + * 判断 scope 中是否包含非空的 urlpatterns 赋值 + */ + private scopeHasUrlpatterns(scope: ASTObject): boolean { + const urlpatternsVal = scope.value?.urlpatterns + if (!urlpatternsVal) return false + + const ast = urlpatternsVal.ast?.node + if (!ast) return false + + // 仅列表字面量且包含元素时视为有效 urlpatterns + // exec() 动态加载产生的 BinaryExpression（如 urlpatterns += frontend_urls）无法静态分析 + if (ast.type !== 'ObjectExpression') return false + if (!ast.properties || ast.properties.length === 0) return false + + return true + } + + /** + * 从模块 scope 中查找 urlpatterns 并递归采集 entrypoint + */ + collectUrlpatternsFromScope( + analyzer: any, + scope: ASTObject, + state: any, + visitedFiles: Set + ): void { + const urlpatternsVal = scope.value?.urlpatterns + if (!urlpatternsVal) return + + const urlpatternsAst = urlpatternsVal.ast?.node + if (urlpatternsAst) { + this.collectDjangoEntrypointAndSource( + analyzer, scope, state, urlpatternsAst, visitedFiles + ) + } + } + + /** + * 采集函数视图的 entrypoint 和 source + * 当 processInstruction 返回 symbol 而非 fclos 时，延迟到后续文件加载后重试 */ collectFuncViewEntrypointAndSource( analyzer: any, @@ -129,35 +473,49 @@ class DjangoTaintChecker extends PythonTaintAbstractChecker { ) { const ep = analyzer.processInstruction(scope, viewFunction, state) if (ep.vtype === 'fclos') { - analyzer.entryPoints.push(completeEntryPoint(ep)) - if (targetSrcName.length > 0) { - const targetName = targetSrcName[0] - for (const param of ep.ast.fdef.parameters) { - if (param.id.name === targetName) { - this.sourceScope.value.push({ - path: param.id.name, - kind: 'PYTHON_INPUT', - scopeFile: extractRelativePath(param?.loc?.sourcefile, Config.maindir), - scopeFunc: ep.ast.fdef?.id?.name, - locStart: param.loc.start?.line, - locEnd: param.loc.end?.line, - }) - } - } - } + this.registerFuncViewEntrypoint(analyzer, ep, targetSrcName) + } else if (ep.vtype === 'symbol') { + // 模块尚未加载，延迟处理 + this.pendingViews.push({ analyzer, scope, state, viewFunction, targetSrcName }) + } + } + + /** + * 注册函数视图 entrypoint 及其 source 参数 + */ + private registerFuncViewEntrypoint( + analyzer: any, + ep: any, + targetSrcName: string[] + ): void { + analyzer.entryPoints.push(completeEntryPoint(ep)) + if (targetSrcName.length > 0) { + const targetName = targetSrcName[0] for (const param of ep.ast.fdef.parameters) { - if (param.id.name === 'request') { + if (param.id.name === targetName) { this.sourceScope.value.push({ path: param.id.name, kind: 'PYTHON_INPUT', scopeFile: extractRelativePath(param?.loc?.sourcefile, Config.maindir), scopeFunc: ep.ast.fdef?.id?.name, - locStart: param.loc.start.line, - locEnd: param.loc.end.line, + locStart: param.loc.start?.line, + locEnd: param.loc.end?.line, }) } } } + for (const param of ep.ast.fdef.parameters) { + if (param.id.name === 'request') { + this.sourceScope.value.push({ + path: param.id.name, + kind: 'PYTHON_INPUT', + scopeFile: extractRelativePath(param?.loc?.sourcefile, Config.maindir), + scopeFunc: ep.ast.fdef?.id?.name, + locStart: param.loc.start.line, + locEnd: param.loc.end.line, + }) + } + } } /** diff --git a/src/checker/taint/python/httpserver-taint-checker.ts b/src/checker/taint/python/httpserver-taint-checker.ts new file mode 100644 index 00000000..5ea1eed0 --- /dev/null +++ b/src/checker/taint/python/httpserver-taint-checker.ts @@ -0,0 +1,168 @@ +import { getLegacyArgValues } from '../../../engine/analyzer/common/call-args' + +const { PythonTaintAbstractChecker } = require('./python-taint-abstract-checker') +const Config = require('../../../config') +const completeEntryPoint = require('../common-kit/entry-points-util') +const { markTaintSource } = require('../common-kit/source-util') +const { isHttpHandlerClass, HTTP_HANDLER_METHODS } = require('../../../engine/analyzer/python/httpserver/entrypoint-collector/httpserver-entrypoint') +const { extractRelativePath } = require('../../../util/file-util') + +// 记录已注册的 HTTP handler 类，避免重复注册 +const registeredHandlerClasses = new WeakSet() + +/** + * Python http.server 框架 taint checker + * 动态检测 HTTP handler 类并注册入口点，标记请求体来源为污点 + */ +class HttpServerTaintChecker extends PythonTaintAbstractChecker { + constructor(resultManager: any) { + super(resultManager, 'taint_flow_python_httpserver_input') + } + + /** + * 初始化：添加 checker 的 taint tag 到 sources 和 rule config + */ + triggerAtStartOfAnalyze(analyzer: any, scope: any, node: any, state: any, info: any): void { + this.addSourceTagForcheckerRuleConfigContent('PYTHON_INPUT', this.checkerRuleConfigContent) + } + + /** + * 函数调用后触发： + * 1. 检测返回值是否是 HTTP handler 类，若是则注册 do_* 方法为入口点 + * 2. 检测 rfile.read() 调用，标记返回值为污点来源 + */ + triggerAtFunctionCallAfter(analyzer: any, scope: any, node: any, state: any, info: any): void { + super.triggerAtFunctionCallAfter(analyzer, scope, node, state, info) + + const { fclos, ret, callInfo } = info + const argvalues = getLegacyArgValues(callInfo) + + if (Config.entryPointMode === 'ONLY_CUSTOM') return + + // 检测 rfile.read() 调用 → 标记返回值为污点来源 + this.markRfileReadAsSource(node, ret) + + // 检测函数返回值是否是 HTTP handler 类 + if (ret && (ret.vtype === 'class' || ret.vtype === 'scope')) { + this.tryRegisterHttpHandlerEntryPoints(analyzer, ret) + } + + // 检测参数中是否有 HTTP handler 类（如 HTTPServer.__init__(self, addr, HandlerClass)） + if (argvalues && Array.isArray(argvalues)) { + for (const arg of argvalues) { + if (arg && (arg.vtype === 'class' || arg.vtype === 'scope')) { + this.tryRegisterHttpHandlerEntryPoints(analyzer, arg) + } + } + } + } + + /** + * 属性访问触发：检测 self.rfile 等属性访问，标记为污点来源 + * 注意：只在 HTTP handler 方法上下文中触发 + */ + triggerAtMemberAccess(analyzer: any, scope: any, node: any, state: any, info: any): void { + if (this.isHttpRequestBodyAccess(node)) { + markTaintSource(info.res, { path: node, kind: 'PYTHON_INPUT' }) + } + } + + /** + * 检测 rfile.read() 调用并标记返回值为污点来源 + * 匹配模式：self.rfile.read(...) 或 rfile.read(...) + */ + private markRfileReadAsSource(node: any, ret: any): void { + if (!node || node.type !== 'CallExpression') return + if (!ret) return + const callee = node.callee + if (callee?.type !== 'MemberAccess') return + const methodName = callee.property?.name + if (methodName !== 'read' && methodName !== 'readline' && methodName !== 'readlines') return + // 检查 callee.object 是否是 rfile 属性访问 + const obj = callee.object + if (!obj) return + // 匹配 self.rfile 或直接 rfile + const isRfile = + (obj.type === 'MemberAccess' && + obj.object?.name === 'self' && + obj.property?.name === 'rfile') || + (obj.type === 'Identifier' && obj.name === 'rfile') + if (isRfile) { + markTaintSource(ret, { path: node, kind: 'PYTHON_INPUT' }) + } + } + + /** + * 检测属性访问是否是 HTTP 请求相关属性（如 self.headers、self.path 等） + */ + private isHttpRequestBodyAccess(node: any): boolean { + if (node?.type !== 'MemberAccess') return false + const obj = node.object + // 匹配 self.rfile / self.headers / self.path / self.command 等 + return ( + obj?.type === 'Identifier' && + obj?.name === 'self' && + ['rfile', 'headers', 'path', 'command', 'request_version', 'raw_requestline'].includes( + node.property?.name + ) + ) + } + + /** + * 尝试将 HTTP handler 类的 do_* 方法注册为入口点 + * @param analyzer 分析器实例 + * @param cls 类符号值 + */ + private tryRegisterHttpHandlerEntryPoints(analyzer: any, cls: any): void { + if (!isHttpHandlerClass(cls)) return + if (registeredHandlerClasses.has(cls)) return + registeredHandlerClasses.add(cls) + + // 从类的 value 字典中查找 HTTP handler 方法 + const classValue = cls.value?.value || cls.value || {} + for (const methodName of HTTP_HANDLER_METHODS) { + const fclos = classValue[methodName] + if (!fclos) continue + + // 必须有 ast.node 才能被引擎执行，否则会导致 executeSingleCall 崩溃 + if (!fclos?.ast?.node) continue + + const ep = completeEntryPoint(fclos) + if (!ep) continue + + ep.funcReceiverType = cls.ast?.node?.id?.name || cls.sid || 'Handler' + + // 避免重复注册 + const isDuplicate = analyzer.entryPoints.some( + (existing: any) => + existing.functionName === ep.functionName && + existing.filePath === ep.filePath && + existing.funcReceiverType === ep.funcReceiverType + ) + if (!isDuplicate) { + analyzer.entryPoints.push(ep) + } + + // 将 self 注册为污点来源 + const selfParam = (fclos.ast?.fdef?.parameters || fclos.ast?.node?.parameters || []).find( + (p: any) => (p.id?.name || p.name) === 'self' + ) + if (selfParam) { + const sourceFile = extractRelativePath( + fclos?.ast?.node?.loc?.sourcefile || ep.filePath, + Config.maindir + ) + this.sourceScope.value.push({ + path: 'self', + kind: 'PYTHON_INPUT', + scopeFile: sourceFile, + scopeFunc: ep.functionName, + locStart: selfParam.loc?.start?.line, + locEnd: selfParam.loc?.end?.line, + }) + } + } + } +} + +module.exports = HttpServerTaintChecker diff --git a/src/checker/taint/python/python-taint-abstract-checker.ts b/src/checker/taint/python/python-taint-abstract-checker.ts index 9ea5da23..542a98c9 100644 --- a/src/checker/taint/python/python-taint-abstract-checker.ts +++ b/src/checker/taint/python/python-taint-abstract-checker.ts @@ -1,4 +1,5 @@ import type { CallInfo } from '../../../engine/analyzer/common/call-args' +import { getLegacyArgValues } from '../../../engine/analyzer/common/call-args' const _ = require('lodash') const commonUtil = require('../../../util/common-util') @@ -75,7 +76,7 @@ class PythonTaintAbstractChecker extends TaintChecker { * @param info */ triggerAtFunctionCallAfter(analyzer: any, scope: any, node: any, state: any, info: any) { - const { fclos, ret } = info + const { fclos, ret, callInfo } = info const funcCallReturnValueTaintSource = this.checkerRuleConfigContent.sources?.FuncCallReturnValueTaintSource IntroduceTaint.introduceTaintAtFuncCallReturnValue(fclos, node, ret, funcCallReturnValueTaintSource) @@ -111,16 +112,6 @@ class PythonTaintAbstractChecker extends TaintChecker { * @param state * @param qid */ - // 去除 qid 中每个 `.` 分隔段的调用参数元数据，如 connect(with(config)) → connect - stripCallMetadata(qid: string): string { - return qid - .split('.') - .map((seg) => { - const parenIdx = seg.indexOf('(') - return parenIdx >= 0 ? seg.substring(0, parenIdx) : seg - }) - .join('.') - } /** * @@ -147,9 +138,9 @@ class PythonTaintAbstractChecker extends TaintChecker { this.findArgsAndAddNewFinding(node, callInfo, fclos, rule, state) return true } - // 去除参数元数据后做后缀匹配 - const stripped = this.stripCallMetadata(callFull) - if (stripped.endsWith(rule.fsig)) { + // 去除参数元数据后匹配：无 '.' 的裸函数名只精确匹配，有 '.' 的允许后缀匹配 + const stripped = QidUnifyUtil.removeParenthesesFromString(callFull) + if (stripped === rule.fsig || (rule.fsig.includes('.') && stripped.endsWith(`.${rule.fsig}`))) { this.findArgsAndAddNewFinding(node, callInfo, fclos, rule, state) return true } @@ -219,7 +210,8 @@ class PythonTaintAbstractChecker extends TaintChecker { const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -230,7 +222,8 @@ class PythonTaintAbstractChecker extends TaintChecker { TAINT_TAG_NAME_PYTHON, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) diff --git a/src/checker/taint/python/python-taint-checker.ts b/src/checker/taint/python/python-taint-checker.ts index 299cd480..c95ffeac 100644 --- a/src/checker/taint/python/python-taint-checker.ts +++ b/src/checker/taint/python/python-taint-checker.ts @@ -1,6 +1,7 @@ const _ = require('lodash') const { PythonTaintAbstractChecker } = require('./python-taint-abstract-checker') const CommonUtil = require('../../../util/common-util') +const { lodashCloneWithTag } = require('../../../util/clone-util') const { findPythonFcEntryPointAndSource, buildFclosIndex, @@ -95,6 +96,9 @@ class PythonTaintChecker extends PythonTaintAbstractChecker { entryPoint.filePath = entrypoint.filePath entryPoint.functionName = entrypoint.functionName entryPoint.attribute = entrypoint.attribute + // 透传函数定义行号，用于精确匹配 overloaded 同名函数 + entryPoint.funcLocStart = entrypoint.funcLocStart + entryPoint.funcLocEnd = entrypoint.funcLocEnd funCallEntryPoints.push(entryPoint) } else { const entryPoint = new EntryPoint(Constant.ENGIN_START_FILE_BEGIN) @@ -117,16 +121,63 @@ class PythonTaintChecker extends PythonTaintAbstractChecker { continue } - // 去重 - valFuncs = _.uniqBy(valFuncs, (value: any) => value.ast.fdef) + // 去重，并过滤掉 ast.node 为 null 的 fclos（防止 executeSingleCall 崩溃） + valFuncs = _.uniqBy(valFuncs, (value: any) => value.ast?.fdef) + valFuncs = valFuncs.filter((value: any) => value?.ast?.node != null) for (const valFunc of valFuncs) { - const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) - entryPoint.filePath = funCallEntryPoint.filePath - entryPoint.functionName = funCallEntryPoint.functionName - entryPoint.attribute = funCallEntryPoint.attribute - entryPoint.entryPointSymVal = valFunc - this.entryPoints.push(entryPoint) + // 当 entrypoint 携带函数行号且 fclos 存在 overloaded 时，精确匹配对应的函数体 + const overloaded = valFunc.overloaded + if (funCallEntryPoint.funcLocStart != null && overloaded != null && overloaded.length > 0) { + // overloaded 可能是 AstRefList（无 find 方法），用 filter 查找行号匹配的函数体 + const matched = overloaded.filter( + (ol: any) => ol.loc?.start?.line === funCallEntryPoint.funcLocStart + ) + const matchedOverload = matched.length > 0 ? matched[0] : null + // 也检查主函数体是否匹配 + const mainMatches = valFunc.ast?.node?.loc?.start?.line === funCallEntryPoint.funcLocStart + if (matchedOverload) { + // overloaded 列表中找到匹配，用匹配的函数体创建精确 entrypoint + const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) + entryPoint.filePath = funCallEntryPoint.filePath + entryPoint.functionName = funCallEntryPoint.functionName + entryPoint.attribute = funCallEntryPoint.attribute + // 使用与 python-analyzer.ts symbolInterpret 相同的克隆模式 + const cloned = lodashCloneWithTag(valFunc) + const clonedDef = _.clone(matchedOverload) + cloned.ast.fdef = clonedDef + cloned.ast = clonedDef + cloned.overloaded = [] + entryPoint.entryPointSymVal = cloned + this.entryPoints.push(entryPoint) + } else if (mainMatches) { + // 主函数体匹配，清空 overloaded 避免遍历其他同名函数 + const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) + entryPoint.filePath = funCallEntryPoint.filePath + entryPoint.functionName = funCallEntryPoint.functionName + entryPoint.attribute = funCallEntryPoint.attribute + const cloned = lodashCloneWithTag(valFunc) + cloned.overloaded = [] + entryPoint.entryPointSymVal = cloned + this.entryPoints.push(entryPoint) + } else { + // 行号不匹配任何函数体，回退到原有行为 + const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) + entryPoint.filePath = funCallEntryPoint.filePath + entryPoint.functionName = funCallEntryPoint.functionName + entryPoint.attribute = funCallEntryPoint.attribute + entryPoint.entryPointSymVal = valFunc + this.entryPoints.push(entryPoint) + } + } else { + // 无行号信息或无 overloaded，保持原有行为（向后兼容） + const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) + entryPoint.filePath = funCallEntryPoint.filePath + entryPoint.functionName = funCallEntryPoint.functionName + entryPoint.attribute = funCallEntryPoint.attribute + entryPoint.entryPointSymVal = valFunc + this.entryPoints.push(entryPoint) + } } } diff --git a/src/checker/taint/python/tornado-taint-checker.ts b/src/checker/taint/python/tornado-taint-checker.ts index f3e96c6b..d4adcf73 100644 --- a/src/checker/taint/python/tornado-taint-checker.ts +++ b/src/checker/taint/python/tornado-taint-checker.ts @@ -266,7 +266,7 @@ class TornadoTaintChecker extends PythonTaintAbstractChecker { * @param info */ triggerAtMemberAccess(analyzer: any, scope: any, node: any, state: any, info: any): void { - if (Config.entryPointMode !== 'ONLY_CUSTOM' && isRequestAttributeAccess(node)) { + if (isRequestAttributeAccess(node)) { markTaintSource(info.res, { path: node, kind: 'PYTHON_INPUT' }) } } diff --git a/src/checker/taint/taint-checker.ts b/src/checker/taint/taint-checker.ts index ab7800dd..678cc01b 100644 --- a/src/checker/taint/taint-checker.ts +++ b/src/checker/taint/taint-checker.ts @@ -1,11 +1,13 @@ const _ = require('lodash') const Checker = require('../common/checker') +const Config = require('../../config') const TaintCheckerAstUtil = require('../../util/ast-util') const TaintCheckerFindingUtil = require('../../util/finding-util') const TaintCheckerSourceLine = require('../../engine/analyzer/common/source-line') const entryPointConfig = require('../../engine/analyzer/common/current-entrypoint') const TaintCheckerRules = require('../common/rules-basic-handler') const taintCheckerCommonUtil = require('../../util/common-util') +const QidUnifyUtil = require('../../util/qid-unify-util') /** * basic class for taint-flow checker @@ -58,7 +60,7 @@ class TaintChecker extends Checker { finding.sinkRule = arr[0] } else if (arr.length === 2) { finding.sinkRule = arr[0] - finding.sinkAttribute = arr[1] + finding.sinkAttribute = arr[1].split(',') } finding.sinkInfo = { sinkRule: finding.sinkRule, @@ -66,34 +68,377 @@ class TaintChecker extends Checker { } const currentEntryPoint = entryPointConfig.getCurrentEntryPoint() finding.entrypointLoc = currentEntryPoint?.entryPointSymVal?.ast?.node?.loc - finding.entrypoint = _.pickBy( - _.clone(currentEntryPoint), - (value: any) => !_.isObject(value) - ) + finding.entrypoint = _.pickBy(_.clone(currentEntryPoint), (value: any) => !_.isObject(value)) finding.trace.push(trace) finding.matchedSanitizerTags = matchedSanitizerTags finding.callstack = callstack + // R21 判据 A：对 live callstack 中 body 内零 step 的 fclos 追加 synthetic CALL+ARG PASS step。 + // 仅在 taintTraceOutputStrategy=callstack-only（默认）下自动生效；非 CO 模式下 raw trace 本身已含 helper body step，无需补齐。 + const traceStrategy = Config.taintTraceOutputStrategy + const isCallstackOnly = traceStrategy === 'callstack-only' || traceStrategy === 'folded' || !traceStrategy + if (isCallstackOnly) { + this.filterTraceToCallstackOrder(finding) + this.synthesizeBridgeSteps(finding) + if (!this.verifyCallstackEdgeInvariant(finding)) return null + } } this.filterDuplicateSource(finding) return finding } + /** + * 计算 step 在 callstack 中的 innermost 覆盖 fclos idx（最深覆盖）。返回 -1 表示该 step 不在任何 + * callstack fclos body 范围内（helper 函数体 / 外部）。 + * @param step + * @param callstack + */ + private getStepInnermostIdx(step: any, callstack: any[]): number { + const sFile = step?.node?.loc?.sourcefile || step?.file + const sLineRaw = step?.node?.loc?.start?.line ?? step?.line + const sLine = Array.isArray(sLineRaw) ? sLineRaw[0] : sLineRaw + if (typeof sLine !== 'number') return -1 + let innermost = -1 + for (let j = 0; j < callstack.length; j++) { + const loc = callstack[j]?.ast?.node?.loc + if (!loc?.sourcefile || typeof loc.start?.line !== 'number' || typeof loc.end?.line !== 'number') continue + if (sFile === loc.sourcefile && sLine >= loc.start.line && sLine <= loc.end.line) { + if (j > innermost) innermost = j + } + } + return innermost + } + + /** + * 两阶段裁剪 trace 到 callstack 对齐状态： + * + * Step 1a：丢弃所有 `innermost === -1`（不在任何 callstack fclos body 内）的 step——helper 函数体里的 + * CALL / ARG PASS / Var Pass / CALL RETURN 等都会被清除。SOURCE / SINK step 例外保留（它们的 loc 可能 + * 指向不在 callstack 的上下文，但语义上必须保留）。 + * + * Step 1b：walk 剩余 trace，维护 `expected`（下一跳应进入的 callstack idx，初始 = 1）。遇到 ARG PASS： + * - innermost === expected（callee-side，在被调方 body 内）→ 接受，expected++ + * - innermost === expected - 1（caller-side，在 caller body 内）→ 接受，expected++（放宽） + * - 其它（包括 innermost > expected 的跳层、innermost < expected-1 的回跳、以及 expected 已到顶之后的 + * 多余 ARG PASS）→ 丢弃，同时把紧邻前一个 CALL step 一起丢（成对清理，避免孤儿 CALL） + * + * 执行完后 trace 里的 CALL+ARG PASS 对严格对应 callstack 的跳转序列（可能仍有缺失，缺失由后续 + * synthesizeBridgeSteps 合成补齐）。 + * @param finding + */ + filterTraceToCallstackOrder(finding: any): void { + const callstack = finding?.callstack + const trace = finding?.trace + if (!Array.isArray(callstack) || !Array.isArray(trace)) return + + // Step 1a：清掉 callstack 外的所有 step（SOURCE/SINK 豁免） + const inCallstack = trace.filter((s: any) => { + if (s?.tag === 'SOURCE: ' || s?.tag === 'SINK: ') return true + return this.getStepInnermostIdx(s, callstack) >= 0 + }) + + // Step 1b：CALL+ARG PASS 对按 callstack 顺序过滤 + let expected = 1 + const drop = new Set() + for (let i = 0; i < inCallstack.length; i++) { + const s = inCallstack[i] + if (s?.tag !== 'ARG PASS: ') continue + const inner = this.getStepInnermostIdx(s, callstack) + // 只有 expected 尚未到达栈顶时才有新跳转可接受；inner 等于 expected（callee-side）或 expected-1（caller-side）即视为合法下一跳 + if (expected < callstack.length && (inner === expected || inner === expected - 1)) { + expected++ + } else { + drop.add(i) + // 成对丢弃：紧邻前一个 CALL step 是这条 ARG PASS 的 caller，一起清理避免孤儿 CALL + if (i > 0 && inCallstack[i - 1]?.tag === 'CALL: ') drop.add(i - 1) + } + } + + finding.trace = inCallstack.filter((_: any, i: number) => !drop.has(i)) + } + + /** + * 校验 CO 模式下 callstack 与 trace 的点-边不变量：callstack.length+1（点数：fclos+sink 条目）必须 + * 等于 "有效 CALL+ARG PASS 对数 + SINK 数"（边数）+ 1。 + * + * 有效对：ARG PASS step 的 innermost 覆盖 fclos 为 callstack 非入口条目（idx ≥ 1）。Helper 函数 + * （如 `getUrl`，不在 sink 时 callstack 上）的 CALL+ARG PASS 不计。按 fclos idx 去重——同 fclos 多个 + * ARG PASS 只算 1 对。 + * + * 违反即说明 synthesizeBridgeSteps 漏补桥接帧或 trace 与 callstack 结构不一致，返回 false 让上层丢弃 finding。 + * @param finding + * @returns true 表示通过校验；false 表示违反不变量，finding 应被丢弃 + */ + verifyCallstackEdgeInvariant(finding: any): boolean { + const callstack = finding?.callstack + const trace = finding?.trace + if (!Array.isArray(callstack) || !Array.isArray(trace)) return true + + // 收集所有 ARG PASS step innermost 覆盖的 fclos idx（仅 idx >= 1） + const argPassFclosIdx = new Set() + for (const s of trace) { + if (s?.tag !== 'ARG PASS: ') continue + const sFile = s?.node?.loc?.sourcefile || s?.file + const sLineRaw = s?.node?.loc?.start?.line ?? s?.line + const sLine = Array.isArray(sLineRaw) ? sLineRaw[0] : sLineRaw + if (typeof sLine !== 'number') continue + let innermost = -1 + for (let j = 0; j < callstack.length; j++) { + const loc = callstack[j]?.ast?.node?.loc + if (!loc?.sourcefile || typeof loc.start?.line !== 'number' || typeof loc.end?.line !== 'number') continue + if (sFile === loc.sourcefile && sLine >= loc.start.line && sLine <= loc.end.line) { + if (j > innermost) innermost = j + } + } + if (innermost >= 1) argPassFclosIdx.add(innermost) + } + + const pairs = argPassFclosIdx.size + const sinks = trace.filter((s: any) => s?.tag === 'SINK: ').length + // 与 synthesizeBridgeSteps 的 fcloses 收录条件保持对齐：只数 callstack 中有合法 loc（含 sourcefile + start/end line） + // 的条目，再 +1 计入 SARIF prepareCallstackElements 追加的 sink 条目。无 loc 的桥接帧（如 lib summary 的 + // `.Promise`）合成阶段拿不到 file:line 也补不出 CALL+ARG PASS，按节点数计入会让 invariant 永远失衡。 + let countedFcloses = 0 + for (const fclos of callstack) { + const loc = fclos?.ast?.node?.loc + if (!loc?.sourcefile || typeof loc.start?.line !== 'number' || typeof loc.end?.line !== 'number') continue + countedFcloses++ + } + const nodes = countedFcloses + 1 + const edges = pairs + sinks + return nodes === edges + 1 + } + + /** + * 对 finding.callstack 中"body 内零 trace step"的 fclos 插入一对 synthetic CALL + ARG PASS step。 + * + * 核心算法（按 callstack 深度穿插插入，而非一律追加末尾）： + * 1. 给 callstack 每个 fclos 编 depth（= 其在 callstack 的 idx，0 = 最外层入口，高 = 更深） + * 2. 给 trace 每个非合成 step 算 depth = callstack 中包含该 step file:line 的 **最深** fclos idx + * 3. 找出 "没有任何 step 落在其 body 内" 的 fclos（uncovered fclos） + * 4. 对每个 uncovered fclos f @ depth d： + * 在 trace 中找到第一个 depth(step) ≥ d 的 step，把 CALL+ARG PASS(f) 插在该 step 之前 + * （即：从 callstack 浅处走向 ≥ d 的深度转换点） + * + * synthetic step 的 node 字段设为 fclos.ast.node（FunctionDefinition），使 SARIF 的 codeFlow + * nodeHash（取自 item.node._meta.nodehash）恰等于 callstack 对应条目的 nodeHash。 + * + * 标记 _synthetic:true 供 isNewFinding 在 CO 折叠判据时过滤合成 step 再比较，防止 degenerate + * SOURCE+SINK 折叠被破坏。_synthetic 字段不经 SARIF 序列化路径。 + * + * 同一 beforeIdx 多条 uncovered fclos 按深度从 inner 到 outer 依次 splice，splice 的"插入即推后" + * 语义使最终 trace 中外层 fclos 排在内层之前；SINK step 保持末尾。 + * @param finding + */ + synthesizeBridgeSteps(finding: any): void { + const callstack = finding?.callstack + const trace = finding?.trace + const callsites = finding?.callsites + if (!Array.isArray(callstack) || !Array.isArray(trace) || trace.length === 0) return + + type FclosInfo = { + idx: number + file: string + startLine: number + endLine: number + node: any + fname: string + } + const fcloses: FclosInfo[] = [] + callstack.forEach((fclos: any, idx: number) => { + if (!fclos || fclos.vtype !== 'fclos') return + const loc = fclos.ast?.node?.loc + const sourcefile: string | undefined = loc?.sourcefile + const startLine = loc?.start?.line + const endLine = loc?.end?.line + if (!sourcefile || typeof startLine !== 'number' || typeof endLine !== 'number') return + // fname 用 QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix 统一清洗：去掉 `` / `.packageManager` / + // `` / `` / `` / `` 等流敏感标签与 yasa 内部前缀，保证 affectedNodeName 可读 + const rawName = fclos.ast?.node?.id?.name || fclos.fname || fclos.qid || '' + const cleanedName = QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(rawName) || rawName + fcloses.push({ + idx, + file: sourcefile, + startLine, + endLine, + node: fclos.ast.node, + fname: cleanedName, + }) + }) + if (fcloses.length === 0) return + + const sinkIdx = trace.length - 1 + const sinkStepIsSinkTag = trace[sinkIdx]?.tag === 'SINK: ' + + // 计算每个 step 的 depth（最深覆盖 fclos idx）；未被任何 fclos 覆盖的 step depth=-1。 + // 合成 step 也正常参与深度计算，保证 synthesizeBridgeSteps 幂等（二次调用时合成 ARG PASS 已覆盖原 uncovered fclos 不会再次注入）。 + const depths: number[] = trace.map((s: any) => { + const sFile = s?.node?.loc?.sourcefile || s?.file + const sLineRaw = s?.node?.loc?.start?.line ?? s?.line + const sLine = Array.isArray(sLineRaw) ? sLineRaw[0] : sLineRaw + if (typeof sLine !== 'number') return -1 + let innermost = -1 + for (const f of fcloses) { + if (sFile === f.file && sLine >= f.startLine && sLine <= f.endLine) { + if (f.idx > innermost) innermost = f.idx + } + } + return innermost + }) + + // fclos 覆盖判据：body 内需要至少一条 ARG PASS step（自然或合成均可）。 + // 闭包捕获场景下深层 fclos 只会出现 SOURCE 而无形参 ARG PASS，必须由 synthesize 补桥接，否则 + // verifyCallstackEdgeInvariant 数不到这一对会丢整条 finding；故此处 SOURCE 不再计为已覆盖。 + const coveredByArgPass = new Set() + trace.forEach((s: any, i: number) => { + if (depths[i] < 0) return + if (s?.tag === 'ARG PASS: ') { + coveredByArgPass.add(depths[i]) + } + }) + // 入口 fclos（idx 0）不需要合成（它由 SOURCE step 标记入参），其它 fclos 若无 ARG PASS 覆盖即需合成 + const uncovered = fcloses.filter((f) => f.idx > 0 && !coveredByArgPass.has(f.idx)) + if (uncovered.length === 0) return + + // 为每个 uncovered fclos 找插入位置：trace 中第一个 depth >= f.idx 的 step；找不到则在 SINK 前兜底 + // 跳过 _synthetic step（保证幂等）和 SOURCE step（语义：SOURCE 是污点起点，应排在 CALL/ARG PASS 之前） + type Insertion = { beforeIdx: number; fclos: FclosInfo } + const insertions: Insertion[] = [] + for (const f of uncovered) { + let beforeIdx = sinkStepIsSinkTag ? sinkIdx : trace.length + for (let i = 0; i < trace.length; i++) { + if (sinkStepIsSinkTag && i === sinkIdx) break + if (trace[i]?._synthetic) continue + if (trace[i]?.tag === 'SOURCE: ') continue + if (depths[i] >= f.idx) { + beforeIdx = i + break + } + } + insertions.push({ beforeIdx, fclos: f }) + } + + // 按 beforeIdx 降序处理，避免前插导致后续 idx 失效；同 beforeIdx 时 fclos.idx 降序（inner 先 splice + // 进去，外层后 splice 会占据更靠前位置，最终 outer→inner 顺序正确） + insertions.sort((a, b) => { + if (a.beforeIdx !== b.beforeIdx) return b.beforeIdx - a.beforeIdx + return b.fclos.idx - a.fclos.idx + }) + + for (const ins of insertions) { + // 选 signature 行：优先 fdef.id（方法名所在行），其次 body 起始行，最后回落到 fdef.loc.start.line。 + // fdef.loc.start 可能落在注解（@Override）或匿名类 new 表达式所在行，导致 SARIF snippet 取到错误源码。 + const idLine = ins.fclos.node?.id?.loc?.start?.line + const bodyLine = ins.fclos.node?.body?.loc?.start?.line + const signatureLine: number = + typeof idLine === 'number' ? idLine : typeof bodyLine === 'number' ? bodyLine : ins.fclos.startLine + // ARG PASS wrapper：loc 落 callee 签名行，_meta.nodehash 经原型继承自 fdef.ast.node（保 callstack nodeHash 等式） + const argPassNode = Object.create(ins.fclos.node) + argPassNode.loc = { + sourcefile: ins.fclos.file, + start: { line: signatureLine, column: 0 }, + end: { line: signatureLine, column: 0 }, + } + // CALL wrapper：优先用 finding.callsites[idx] 的真实 callsite（loc 落在 caller body 的 CallExpression 所在行）， + // nodehash 取 callsites[idx].nodeHash；callsites 缺位或字段不全时回退到 fdef 签名行 + fdef nodehash（与旧行为等价）。 + const callsite = Array.isArray(callsites) ? callsites[ins.fclos.idx] : undefined + const siteLoc = callsite?.loc + const siteLineRaw = siteLoc?.start?.line + const siteLine = Array.isArray(siteLineRaw) ? siteLineRaw[0] : siteLineRaw + const hasSiteLoc = typeof siteLine === 'number' && typeof siteLoc?.sourcefile === 'string' + let callNode: any + let callFile: string + let callLine: number + if (hasSiteLoc) { + callFile = siteLoc.sourcefile + callLine = siteLine + // 以 fdef 为原型，确保 nodehash 缺位时自然回退到 fdef._meta.nodehash + callNode = Object.create(ins.fclos.node) + callNode.loc = siteLoc + if (typeof callsite?.nodeHash !== 'undefined') { + callNode._meta = { nodehash: callsite.nodeHash } + } + } else { + callFile = ins.fclos.file + callLine = signatureLine + callNode = argPassNode + } + const callStep = { + file: callFile, + line: callLine, + tag: 'CALL: ', + node: callNode, + affectedNodeName: ins.fclos.fname, + _synthetic: true, + } + const argPassStep = { + file: ins.fclos.file, + line: signatureLine, + tag: 'ARG PASS: ', + node: argPassNode, + affectedNodeName: ins.fclos.fname, + _synthetic: true, + } + trace.splice(ins.beforeIdx, 0, callStep, argPassStep) + } + + // Pass 2：扫描每个 ARG PASS step，若紧邻前驱不是 CALL（analyzer 在某些 AST 模式下——例如 Python + // fullfileManagerMade 入口或嵌套 def 跨层调用——只写了 ARG PASS 没写 CALL）则按 callsites[innermost_idx] + // 合成一个 CALL 插到它前面，保证 CALL/ARG PASS 成对出现。反向遍历避免 splice 导致索引失效。 + // 仅当 callsite line 与 ARG PASS step line 不同才合成：JS entrypoint 的 callsites[0] 常指向 fclos 自身 + // body 起始行，不是真正的 caller-side callsite，用这种 loc 造 CALL 会重复 ARG PASS 的位置信息。 + for (let i = trace.length - 1; i >= 0; i--) { + const step = trace[i] + if (step?.tag !== 'ARG PASS: ') continue + if (i > 0 && trace[i - 1]?.tag === 'CALL: ') continue + const innermostIdx = this.getStepInnermostIdx(step, callstack) + if (innermostIdx < 0) continue + const callsite = Array.isArray(callsites) ? callsites[innermostIdx] : undefined + const siteLoc = callsite?.loc + const siteLineRaw = siteLoc?.start?.line + const siteLine = Array.isArray(siteLineRaw) ? siteLineRaw[0] : siteLineRaw + if (typeof siteLine !== 'number' || typeof siteLoc?.sourcefile !== 'string') continue + const argPassLineRaw = step?.node?.loc?.start?.line ?? step?.line + const argPassLine = Array.isArray(argPassLineRaw) ? argPassLineRaw[0] : argPassLineRaw + const argPassFile = step?.node?.loc?.sourcefile || step?.file + if (siteLine === argPassLine && siteLoc.sourcefile === argPassFile) continue + const fclos = callstack[innermostIdx] + const rawName = fclos?.ast?.node?.id?.name || fclos?.fname || fclos?.qid || '' + const fname = QidUnifyUtil.qidUnifyByRemoveAngleAndPrefix(rawName) || rawName + const callNode = Object.create(fclos?.ast?.node || {}) + callNode.loc = siteLoc + if (typeof callsite?.nodeHash !== 'undefined') { + callNode._meta = { nodehash: callsite.nodeHash } + } + const callStep = { + file: siteLoc.sourcefile, + line: siteLine, + tag: 'CALL: ', + node: callNode, + affectedNodeName: fname, + _synthetic: true, + } + trace.splice(i, 0, callStep) + } + } + /** * 去掉链路中重复的source，以免链路可读性降低 * @param finding */ filterDuplicateSource(finding: any): void { if (!finding || !finding.trace || !Array.isArray(finding.trace)) return + // 语义：保留 trace 中首个 SOURCE step，丢弃后续重复。原实现按位置（key > 1）判定在 SOURCE 前插入合成 + // CALL/ARG PASS 的场景会误删真实 SOURCE；改为按"已见过一次 SOURCE 就丢后续"的语义。 const newTrace = [] - for (const key in finding.trace) { - if ( - Number(key) > 1 && - (finding.trace[key].tag === 'SOURCE: ' || - (typeof finding.trace[key].str === 'string' && finding.trace[key].str.includes('SOURCE: '))) - ) { - continue - } - newTrace.push(finding.trace[key]) + let sawSource = false + for (const step of finding.trace) { + const isSource = + step?.tag === 'SOURCE: ' || (typeof step?.str === 'string' && step.str.includes('SOURCE: ')) + if (isSource) { + if (sawSource) continue + sawSource = true + } + newTrace.push(step) } finding.trace = newTrace } @@ -119,7 +464,8 @@ class TaintChecker extends Checker { kind: any, ruleName: any, matchedSanitizerTags: any, - callstack: any + callstack: any, + callsites?: any ): any { const taintFlowFinding = this.buildTaintFindingObject( checkerId, @@ -130,7 +476,8 @@ class TaintChecker extends Checker { kind, ruleName, matchedSanitizerTags, - callstack + callstack, + callsites ) return this.buildTaintFindingDetail(taintFlowFinding) } @@ -156,7 +503,8 @@ class TaintChecker extends Checker { kind: any, ruleName: any, matchedSanitizerTags: any, - callstack: any + callstack: any, + callsites?: any ): any { const taintFlowFinding = TaintCheckerRules.getFinding(checkerId, checkerDesc, node) taintFlowFinding.nd = nd @@ -166,6 +514,8 @@ class TaintChecker extends Checker { taintFlowFinding.ruleName = ruleName taintFlowFinding.matchedSanitizerTags = matchedSanitizerTags taintFlowFinding.callstack = callstack + // callsites 与 callstack 长度一致，每项结构 { code, nodeHash, loc }，由 analyzer 在 CallExpression 进入被调函数时入栈 + taintFlowFinding.callsites = callsites return taintFlowFinding } diff --git a/src/checker/taint/test-taint-checker.ts b/src/checker/taint/test-taint-checker.ts index d544e72b..5b5251af 100644 --- a/src/checker/taint/test-taint-checker.ts +++ b/src/checker/taint/test-taint-checker.ts @@ -226,9 +226,12 @@ class TestTaintChecker extends TaintChecker { for (const ndResultWithMatchedSanitizerTags of ndResultWithMatchedSanitizerTagsArray) { const { nd } = ndResultWithMatchedSanitizerTags const { matchedSanitizerTags } = ndResultWithMatchedSanitizerTags + // sanitizer 匹配成功时跳过 finding（sanitizer 消毒生效，仅在 sink 规则配置了 sanitizerIds 时抑制） + if (rule.sanitizerIds?.length > 0 && matchedSanitizerTags && matchedSanitizerTags.length > 0) continue let ruleName = rule.fsig if (typeof rule.attribute !== 'undefined') { - ruleName += `\nSINK Attribute: ${rule.attribute}` + const attrStr = Array.isArray(rule.attribute) ? rule.attribute.join(',') : rule.attribute + ruleName += `\nSINK Attribute: ${attrStr}` } const taintFlowFinding = this.buildTaintFinding( this.getCheckerId(), @@ -239,7 +242,8 @@ class TestTaintChecker extends TaintChecker { TAINT_TAG_NAME_TEST_TAINT, ruleName, matchedSanitizerTags, - state?.callstack + state?.callstack, + state?.callsites ) if (!TaintOutputStrategy.isNewFinding(this.resultManager, taintFlowFinding)) continue this.resultManager.newFinding(taintFlowFinding, TaintOutputStrategy.outputStrategyId) diff --git a/src/config.ts b/src/config.ts index 87e3f23c..b0ea5bf1 100644 --- a/src/config.ts +++ b/src/config.ts @@ -43,6 +43,7 @@ export interface IConfig { format?: string dumpCG?: boolean dumpAllCG?: boolean + dumpEntrypoint?: boolean needBenchmarkJson?: boolean // Rules @@ -111,7 +112,7 @@ const configObject: IConfig = { shareSourceLineSet: false, // Worker数量：0表示自动计算，>0表示使用设置的worker数量 - workerCount: 0, + workerCount: 1, //* ***************************** analysis *************************** @@ -121,6 +122,7 @@ const configObject: IConfig = { i18n: 'ch', // ch | en format: 'sarif', // sarif | json | plaintext | html dumpCG: false, + dumpEntrypoint: false, needBenchmarkJson: true, //* ***************************** rules ***************** loadDefaultRule: true, diff --git a/src/engine/analyzer/common/analyzer.ts b/src/engine/analyzer/common/analyzer.ts index f92ed184..b02bd017 100644 --- a/src/engine/analyzer/common/analyzer.ts +++ b/src/engine/analyzer/common/analyzer.ts @@ -1,4 +1,5 @@ import { primitiveToString } from '../../../util/variable-util' +import { AstRefList } from './value/ast-ref-list' import type { ISymbolTableManager } from './symbol-table-interface' import type { Invocation } from '../../../resolver/common/value/invocation' import type { @@ -731,20 +732,51 @@ class Analyzer extends BaseAnalyzer { this.startAnalyze() this.performanceTracker.end('startAnalyze') - Rules.setPreprocessReady(true) - this.performanceTracker.start('symbolInterpret') + // dumpEntrypoint：收集完入口点后输出 entrypoints.json + if (Config.dumpEntrypoint && Config.reportDir) { + const fs = require('fs') + const path = require('path') + const sourceRoot = this.options?.maindir || Config.maindirPrefix || '' + const entryPointData = { + entryPoints: (this.entryPoints || []).map((ep: any) => { + const loc = ep.entryPointSymVal?.ast?.node?.loc + const location = loc ? { + start: loc.start, + end: loc.end, + sourcefile: loc.sourcefile && sourceRoot && loc.sourcefile.startsWith(sourceRoot) + ? loc.sourcefile.substring(sourceRoot.length) + : (loc.sourcefile || ''), + } : null + return { + filePath: ep.filePath || '', + functionName: ep.functionName || '', + type: ep.type || '', + location, + } + }), + } + const outPath = path.join(Config.reportDir, 'entrypoints.json') + fs.writeFileSync(outPath, JSON.stringify(entryPointData, null, 2)) + logger.info(`EntryPoints dumped to ${outPath} (${entryPointData.entryPoints.length} entries)`) + } - // 切换到临时符号表 - this.switchToTemporarySymbolTable() + // dumpEntrypoint 模式跳过符号解释，但保留 endAnalyze 以兼容 dumpAllCG 等输出 + if (!Config.dumpEntrypoint) { + Rules.setPreprocessReady(true) - try { - this.symbolInterpret() - } finally { - // 恢复原始符号表 - this.restoreSymbolTable() + this.performanceTracker.start('symbolInterpret') + + // 切换到临时符号表 + this.switchToTemporarySymbolTable() + + try { + this.symbolInterpret() + } finally { + this.restoreSymbolTable() + } + this.performanceTracker.end('symbolInterpret') } - this.performanceTracker.end('symbolInterpret') this.endAnalyze() // 记录性能数据并输出摘要（会自动输出指令统计） @@ -1316,7 +1348,7 @@ class Analyzer extends BaseAnalyzer { // 如果是string，将其构造出符号值再存储 // TODO 250731 将符号的字面量(而非符号值)作为key存储是否合适，有待商榷。 if (_.isString(k)) k = new PrimitiveValue(scope.qid, k, k, null, key.type, key.loc, key) - this.saveVarInScope(scope, key, k, state) + this.saveVarInCurrentScope(scope, key, k, state) } } if (value) { @@ -1328,7 +1360,7 @@ class Analyzer extends BaseAnalyzer { this.saveVarInCurrentScope(scope, value.elements[i].name, eleVal, state) } } else { - this.saveVarInScope(scope, value, v, state) + this.saveVarInCurrentScope(scope, value, v, state) } } this.processInstruction(scope, body, state) @@ -1352,7 +1384,7 @@ class Analyzer extends BaseAnalyzer { if (!node.isYield) { if (!this.lastReturnValue) { this.lastReturnValue = returnValue - } else if (this.lastReturnValue.vtype === 'union') { + } else if (this.lastReturnValue.vtype === 'union' && !this.lastReturnValue.isTuple) { if (returnValue === this.lastReturnValue || returnValue.value === this.lastReturnValue.value) { const newReturnValue = buildNewValueInstance( this, @@ -1462,7 +1494,8 @@ class Analyzer extends BaseAnalyzer { * @param state */ processTryStatement(scope: ScopeType, node: TryStatement, state: State): VoidValueType { - // 此处processInstruction的返回值是undefine 因此无法拿到try里面是否抛出异常的信息 + // 初始化 throwstack，使 processThrowStatement 可将抛出值 push 进来 + state.throwstack = state.throwstack ?? [] this.processInstruction(scope, node.body, state) const { handlers } = node if (handlers) { @@ -1604,7 +1637,6 @@ class Analyzer extends BaseAnalyzer { if (this.checkerManager && this.checkerManager.checkAtAssignment) { const lscope = this.getDefScope(scope, x) - const mindex = this.resolveIndices(scope, x, state) this.checkerManager.checkAtAssignment(this, scope, node, state, { lscope, lvalue: oldVal, @@ -1612,7 +1644,6 @@ class Analyzer extends BaseAnalyzer { pcond: state.pcond, binfo: state.binfo, entry_fclos: this.entry_fclos, - mindex, einfo: state.einfo, state, }) @@ -1635,7 +1666,6 @@ class Analyzer extends BaseAnalyzer { } if (this.checkerManager && this.checkerManager.checkAtAssignment) { const lscope = this.getDefScope(scope, left) - const mindex = this.resolveIndices(scope, left, state) this.checkerManager.checkAtAssignment(this, scope, node, state, { lscope, lvalue: oldVal, @@ -1643,7 +1673,6 @@ class Analyzer extends BaseAnalyzer { pcond: state.pcond, binfo: state.binfo, entry_fclos: this.entry_fclos, - mindex, einfo: state.einfo, state, ainfo: this.ainfo, @@ -1694,7 +1723,6 @@ class Analyzer extends BaseAnalyzer { if (this.checkerManager && this.checkerManager.checkAtAssignment) { const lscope = this.getDefScope(scope, node.left) - const mindex = this.resolveIndices(scope, node.left, state) this.checkerManager.checkAtAssignment(this, scope, node, state, { lscope, lvalue: oldVal, @@ -1702,7 +1730,6 @@ class Analyzer extends BaseAnalyzer { pcond: state.pcond, binfo: state.binfo, entry_fclos: this.entry_fclos, - mindex, einfo: state.einfo, state, ainfo: this.ainfo, @@ -1843,7 +1870,12 @@ class Analyzer extends BaseAnalyzer { const values = node.elements.map((ele: any) => { return this.processInstruction(scope, ele, state) }) - return unionAllValues(values, state) + const result = unionAllValues(values, state) + // 非数组的 tuple（如 Python tuple、Go 多返回值）标记 isTuple，防止 return 合并时丢失元素 + if (!(node as any).isArray) { + result.isTuple = true + } + return result } /** @@ -2231,6 +2263,15 @@ class Analyzer extends BaseAnalyzer { const fclos = this.processInstruction(scope, node.callee, state) if (!fclos) return new UndefinedValue() + // 类型转换去污：数值/布尔类型转换不携带注入载荷（如 (int)"1 OR 1=1" → 1） + const numericCastTypes = ['int', 'integer', 'float', 'double', 'bool', 'boolean'] + if (node._meta?.isCast && node.callee?.name && numericCastTypes.includes(node.callee.name)) { + for (const arg of node.arguments) { + this.processInstruction(scope, arg, state) + } + return new PrimitiveValue(scope.qid, ``, node, null, 'Literal', node.loc) + } + // prepare the function arguments let argvalues = [] let same_args = true // minor optimization to save memory @@ -2485,15 +2526,15 @@ class Analyzer extends BaseAnalyzer { if (!id || idName === '_') return new UndefinedValue() // e.g. in Go let initVal - if (!initialNode) { - initVal = this.createVarDeclarationScope(id, scope) - initVal.uninit = !initialNode - initVal = SourceLine.addSrcLineInfo(initVal, id, id.loc && id.loc.sourcefile, 'Var Pass: ', idName || '') - } else if (node?.parent?.type === 'CatchClause' && node?._meta?.isCatchParam && (state?.throwstack?.length ?? 0) > 0) { - // 处理throw传递到catch的情况 + if (node?.parent?.type === 'CatchClause' && node?._meta?.isCatchParam && (state?.throwstack?.length ?? 0) > 0) { + // throw 传递到 catch：从 throwstack 取出抛出值赋给 catch 参数 initVal = state?.throwstack && state?.throwstack.shift() initVal = SourceLine.addSrcLineInfo(initVal, node, node.loc && node.loc.sourcefile, 'Var Pass: ', idName || '') delete node._meta.isCatchParm + } else if (!initialNode) { + initVal = this.createVarDeclarationScope(id, scope) + initVal.uninit = !initialNode + initVal = SourceLine.addSrcLineInfo(initVal, id, id.loc && id.loc.sourcefile, 'Var Pass: ', idName || '') } else { initVal = this.processInstruction(scope, initialNode, state) if (initialNode.type === 'ImportExpression') { @@ -2742,9 +2783,9 @@ class Analyzer extends BaseAnalyzer { callInfo = this.ensureCallInfo(node, fclos, callInfo) const argvalues = getLegacyArgValues(callInfo) if (Config.miniSaveContextEnvironment) { - return new CallExprValue(scope.qid, fclos, argvalues, node, node.loc, fclos) + return new CallExprValue(scope.qid, fclos, argvalues, node, node?.loc, fclos) } - if (Config.makeAllCG && fclos?.ast.fdef?.type === 'FunctionDefinition' && this.ainfo?.callgraph?.nodes) { + if (Config.makeAllCG && state.callstack?.length > 0 && fclos?.ast.fdef?.type === 'FunctionDefinition' && this.ainfo?.callgraph?.nodes) { for (const callgraphnode of this.ainfo?.callgraph?.nodes.values()) { // 从 nodehash 还原 funcDef let callgraphFuncDef = callgraphnode.opts?.funcDef @@ -2768,7 +2809,7 @@ class Analyzer extends BaseAnalyzer { analyzer: this, ainfo: this.ainfo, }) - return new CallExprValue(scope.qid, fclos, argvalues, node, node.loc, fclos) + return new CallExprValue(scope.qid, fclos, argvalues, node, node?.loc, fclos) } } } @@ -2892,7 +2933,9 @@ class Analyzer extends BaseAnalyzer { !res.expression.object && thisVal.taint?.isTaintedRec ) { - res.expression.object = thisVal + if (!res.expression.object) { + res.expression.object = thisVal + } isTainted = true } } @@ -2905,7 +2948,15 @@ class Analyzer extends BaseAnalyzer { res.taint?.markSource() } - // save pass-in arguments for later use + // receiver 污点的形式化数据传播：将 receiver 加入返回值的 buffer，使 satisfy 遍历时能找到 taint tags + if (node.callee?.type === 'MemberAccess' && res.hasTagRec) { + const thisObj = fclos.getThisObj?.() + if (thisObj?.hasTagRec && _.isFunction(res.setMisc)) { + addElementToBuffer(res, thisObj) + } + } + + // 将传入参数存入 misc_，hasTagRec 迭代 misc_ 时可发现污点参数，实现参数→返回值污点传播 if (argvalues.length > 0) { res.setMisc('pass-in', argvalues) } @@ -2948,7 +2999,15 @@ class Analyzer extends BaseAnalyzer { ) matchRuleFound = true } else if (sourceType === 'ARG' && targetType === 'THIS') { - this.processLibArgToThis(node, fclos, argvalues, libFuncTagPropagationRule.source.index, scope, state) + this.processLibArgToThis( + node, + fclos, + argvalues, + libFuncTagPropagationRule.source.index, + scope, + state, + !!libFuncTagPropagationRule.target?.propagateToOwner + ) matchRuleFound = true } else if (sourceType === 'THIS' && targetType === 'ARG') { this.processLibThisToArg(node, fclos, argvalues, libFuncTagPropagationRule.target.index, scope, state) @@ -3012,22 +3071,18 @@ class Analyzer extends BaseAnalyzer { * @param scope * @param state */ - processLibArgToThis(node: any, fclos: any, argvalues: any, sourceIndex: any, scope: any, state: any) { + processLibArgToThis( + node: any, + fclos: any, + argvalues: any, + sourceIndex: any, + scope: any, + state: any, + propagateToOwner: boolean = false + ) { let thisVal = fclos.getThisObj() - if ( - !argvalues || - argvalues.length === 0 || - !thisVal || - !['symbol', 'object'].includes(thisVal.vtype) || - !_.isFunction(thisVal.setMisc) || - this.shouldSkipLibArgToThisPropagation(thisVal) || - thisVal.injected || - thisVal?.parent?.vtype === 'class' || - thisVal?.parent?._isConstructor || - thisVal?._this?.vtype === 'class' || - thisVal?._this?._isConstructor || - thisVal.qid?.startsWith('.syslib_from') - ) { + + if (!argvalues || argvalues.length === 0 || !thisVal || !this.isValidLibArgToThisTarget(thisVal)) { return } @@ -3055,6 +3110,33 @@ class Analyzer extends BaseAnalyzer { } } } + // C.1b getter-chain 反向染：仅当规则 opt-in `propagateToOwner:true` 且 thisVal 真被染后， + // 若 thisVal 是 `owner.getter()` 返回的 SymbolValue（带 expression.object 回指）， + // 同跑一套 arg2this 守卫把 taint 反向传到 owner，1 跳不递归。默认 fallback 恒传 false 不触发。 + // 关键：markSource 只置 hasTag 但不填 tagTraces，而 sink 侧走 tagTraceMap.has(attribute) 判断； + // 必须把 arg 塞进 owner.misc_.buffer，让 sink 侧 satisfy 递归能发现深层语言级 tag（JAVA_INPUT/PYTHON_INPUT 等）， + // 再补 markSource 让 owner.isTaintedRec 短路为 true，与引擎现有 ARG→THIS 的双写口径对齐。 + if (propagateToOwner && thisVal.taint?.isTaintedRec) { + const owner = thisVal.expression?.object + if (owner && this.isValidLibArgToThisTarget(owner)) { + for (const argIndex in argvalues) { + if (sourceIndex >= 0 && sourceIndex !== Number(argIndex)) continue + const arg = argvalues[argIndex] + if (!arg?.taint?.isTaintedRec) continue + addElementToBuffer(owner, arg) + } + owner.taint?.markSource() + if (node?.parent?.type !== 'AssignmentExpression') { + SourceLine.addSrcLineInfo( + owner, + node, + node.loc && node.loc.sourcefile, + 'Var Pass: getter-chain reverse', + owner.sid + ) + } + } + } break case 'Identifier': break @@ -3063,6 +3145,27 @@ class Analyzer extends BaseAnalyzer { } } + /** + * 判断目标 Value 是否可作为 lib arg→this 的染色目标。 + * processLibArgToThis 头部守卫与 opt-in 反向染 owner 复用同一组条件， + * 以保证 §7 arg2this 黑名单 + class/constructor 保护 + syslib 注入守卫对两侧一致生效。 + * @param val 被评估的目标 Unit + */ + isValidLibArgToThisTarget(val: any): boolean { + if (!val) return false + if (!['symbol', 'object'].includes(val.vtype)) return false + if (!_.isFunction(val.setMisc)) return false + if (this.shouldSkipLibArgToThisPropagation(val)) return false + if (val.injected) return false + // 内部类实例（sid 含 .syslib_from')) return false + return true + } + /** * Check whether lib arg->this propagation should be skipped. * @param thisVal @@ -3220,7 +3323,7 @@ class Analyzer extends BaseAnalyzer { let execute_builtin = false if (!fdecl) { if (!fclos.runtime?.execute) { - return new CallExprValue(scope.qid, fclos, argvalues, node, node.loc) + return new CallExprValue(scope.qid, fclos, argvalues, node, node?.loc) } // execute prepared builtins function execute_builtin = true @@ -3242,7 +3345,7 @@ class Analyzer extends BaseAnalyzer { } let extraFuncDefs = [] - const overloadedNodes = fclos.overloaded.filter(() => true) + const overloadedNodes = fclos.overloaded?.filter(() => true) ?? [] if (overloadedNodes.length > 1) { // overloaded functions let hasFind = false @@ -3397,6 +3500,10 @@ class Analyzer extends BaseAnalyzer { const argvalues = getLegacyArgValues(callInfo) if (logger.isTraceEnabled()) logger.trace(`\nprocessCall: function: ${this.formatScope(fdecl?.id?.name)}`) + // 进入函数调用时重置 inRange，避免 for-range body 中调用函数时嵌套 for-range 被错误抑制 + const savedInRange = this.inRange + this.inRange = false + // avoid infinite loops,the re-entry should only less than 3 if ( fdecl && @@ -3404,7 +3511,8 @@ class Analyzer extends BaseAnalyzer { return currentValue.ast.fdef === fdecl ? previousValue + 1 : previousValue }, 0) > 0 ) { - return new CallExprValue(scope.qid, fclos, argvalues, node, node.loc, fclos) + this.inRange = savedInRange + return new CallExprValue(scope.qid, fclos, argvalues, node, node?.loc, fclos) } // pre-call processing @@ -3426,15 +3534,15 @@ class Analyzer extends BaseAnalyzer { ? state.callsites.concat([ { code: AstUtil.getRawCode(node).slice(0, 100), - nodeHash: node._meta?.nodehash, - loc: node.loc, + nodeHash: node?._meta?.nodehash, + loc: node?.loc, }, ]) : [ { code: AstUtil.getRawCode(node).slice(0, 100), - nodeHash: node._meta?.nodehash, - loc: node.loc, + nodeHash: node?._meta?.nodehash, + loc: node?.loc, }, ] new_state.brs = '' @@ -3456,7 +3564,7 @@ class Analyzer extends BaseAnalyzer { // this.lastReturnValue = fclos.runtime.execute.call(this, fclos, argvalues, new_state, node, scope); this.lastReturnValue = null for (let i = 0; i < argvalues.length; i++) { - argvalues[i] = SourceLine.addSrcLineInfo(argvalues[i], node, node.loc && node.loc.sourcefile, 'CALL: ', fname) + argvalues[i] = SourceLine.addSrcLineInfo(argvalues[i], node, node?.loc && node.loc.sourcefile, 'CALL: ', fname) } return_value = fclos.runtime!.execute!.call(this, fclos, argvalues, new_state, node, scope) } else { @@ -3480,6 +3588,7 @@ class Analyzer extends BaseAnalyzer { // process function arguments if (!fdecl.parameters) { + this.inRange = savedInRange return new UndefinedValue() } const params = fdecl.parameters @@ -3609,6 +3718,8 @@ class Analyzer extends BaseAnalyzer { delete fclos.value[fscope.sid] // this.setCurrentFunction(old_function); this.thisFClos = oldThisFClos + // 恢复 inRange，使调用方 for-range 的状态不被嵌套函数调用影响 + this.inRange = savedInRange return return_value } @@ -3707,11 +3818,11 @@ class Analyzer extends BaseAnalyzer { if (Config.invokeCallbackOnUnknownFunction) { this.executeFunctionInArguments(scope, fclos, node, argvalues, state) } - // save pass-in arguments for later use if (argvalues.length > 0) { if (!obj.arguments || (Array.isArray(obj.arguments) && obj.arguments?.length === 0)) { obj.arguments = argvalues } else { + // 将传入参数存入 misc_，hasTagRec 迭代时可发现污点参数 obj.setMisc('pass-in', argvalues) } } @@ -3760,6 +3871,26 @@ class Analyzer extends BaseAnalyzer { ctorClos = obj.value._CTOR_ } } + // 无 __init__ 时查找 __new__，使 __new__ 中的赋值能传播 taint + if (!ctorClos && body) { + let newMethodAst: any + for (const nd of body) { + if (nd.type === 'FunctionDefinition' && nd.name === '__new__') { + newMethodAst = nd + break + } + } + if (newMethodAst) { + this.processInstruction(fclos, newMethodAst, state) + const newClos = obj.value?.['__new__'] + if (newClos?.vtype === 'fclos') { + ctorClos = newClos + paras = newMethodAst.parameters + // __new__ 返回值需要合并回 obj，与 __init__ 不同 + ctorClos.__isNewMethod = true + } + } + } } } if (paras) { @@ -3769,7 +3900,7 @@ class Analyzer extends BaseAnalyzer { const param = paras[i] let index = i const names = node.names || node.arguments - if (names > 0) { + if (names?.length > 0) { // handle named argument values like "f({value: 2, key: 3})" const k = names.indexOf(param.name) if (k !== -1) index = k @@ -3781,7 +3912,7 @@ class Analyzer extends BaseAnalyzer { val, node, param.loc.sourcefile, - 'CTOR ARG PASS: ', + 'ARG PASS: ', param.name || AstUtil.prettyPrint(param).slice(0, 50) ) } @@ -3804,8 +3935,36 @@ class Analyzer extends BaseAnalyzer { const oldThisFClos = this.thisFClos this.thisFClos = obj ctorClos._this = obj - this.executeCall(node, ctorClos, state, scope, callInfo) + // __new__ 的第一个参数是 cls，需要设置 receiver 使 bindReceiverParam 正确跳过 cls + let ctorCallInfo = callInfo + if (ctorClos.__isNewMethod && callInfo?.callArgs) { + ctorCallInfo = { + callArgs: { + ...callInfo.callArgs, + receiver: obj, + }, + } + } + const ctorReturn = this.executeCall(node, ctorClos, state, scope, ctorCallInfo) this.thisFClos = oldThisFClos + + // __new__ 返回值合并：将 __new__ 内部对 instance 的赋值传播到 obj + if (ctorClos.__isNewMethod && ctorReturn) { + if (ctorReturn.value && typeof ctorReturn.value === 'object') { + for (const key of Object.keys(ctorReturn.value)) { + if (!key.startsWith('__') && obj.value && !obj.value[key]) { + obj.value[key] = ctorReturn.value[key] + } + } + } + // 传播 taint + if (ctorReturn.taint?.isTaintedRec) { + obj.taint = obj.taint || {} + if (typeof obj.taint.propagateFrom === 'function') { + obj.taint.propagateFrom(ctorReturn) + } + } + } } if (obj.parent) { @@ -3956,7 +4115,9 @@ class Analyzer extends BaseAnalyzer { if (fieldName === '_CTOR_') { superValue.ast.node = v_copy.ast.fdef superValue.ast.fdef = v_copy.ast.fdef - superValue.overloaded = superValue.overloaded || [] + if (!superValue.overloaded) { + superValue.overloaded = new AstRefList(() => superValue.getASTManager()) + } superValue.overloaded.push(fdef) } } @@ -4020,8 +4181,16 @@ class Analyzer extends BaseAnalyzer { continue } if (typeof fields.hasOwnProperty === 'function' && fields.hasOwnProperty(key)) { - if (!filter) yield { k: key, v: fields[key] } - else if (filter(fields[key])) yield { k: key, v: fields[key] } + let val = fields[key] + // UUID 字符串解析回实际符号值 + if (val && typeof val === 'string' && val.startsWith('symuuid_')) { + const resolved = this.symbolTable.get(val) + if (resolved) { + val = resolved + } + } + if (!filter) yield { k: key, v: val } + else if (filter(val)) yield { k: key, v: val } } } } diff --git a/src/engine/analyzer/common/checker-manager.ts b/src/engine/analyzer/common/checker-manager.ts index 80fde6b3..8a21289a 100644 --- a/src/engine/analyzer/common/checker-manager.ts +++ b/src/engine/analyzer/common/checker-manager.ts @@ -157,6 +157,10 @@ class CheckerManager { } } } + // 0 个 checker 加载成功时抛出异常，无法继续分析 + if (loadCheckerNames.length === 0) { + throw new Error('No checker loaded successfully, cannot proceed with analysis') + } const checkerCount = loadCheckerNames.length yasaLog(`Successfully loaded ${checkerCount} checker(s): [${loadCheckerNames.join(', ')}]`, 'init') } catch (e) { diff --git a/src/engine/analyzer/common/common-types.ts b/src/engine/analyzer/common/common-types.ts index 984c5d05..6785fa21 100644 --- a/src/engine/analyzer/common/common-types.ts +++ b/src/engine/analyzer/common/common-types.ts @@ -35,7 +35,7 @@ export interface TaintFinding { node?: any argNode?: any sinkRule?: string - sinkAttribute?: string + sinkAttribute?: string[] entrypoint?: any sinkInfo?: any format?: any diff --git a/src/engine/analyzer/common/entrypoint.ts b/src/engine/analyzer/common/entrypoint.ts index 99d4f242..ce806116 100644 --- a/src/engine/analyzer/common/entrypoint.ts +++ b/src/engine/analyzer/common/entrypoint.ts @@ -19,6 +19,10 @@ export interface EntryPoint { filePath?: string attribute?: string funcReceiverType?: string + /** 函数定义起始行号，用于精确匹配 overloaded 同名函数 */ + funcLocStart?: number + /** 函数定义结束行号，用于精确匹配 overloaded 同名函数 */ + funcLocEnd?: number [key: string]: any } @@ -42,6 +46,12 @@ class EntryPointClass implements EntryPoint { funcReceiverType: string + /** 函数定义起始行号，用于精确匹配 overloaded 同名函数 */ + funcLocStart: number | undefined + + /** 函数定义结束行号，用于精确匹配 overloaded 同名函数 */ + funcLocEnd: number | undefined + /** * * @param type @@ -55,6 +65,8 @@ class EntryPointClass implements EntryPoint { this.filePath = '' this.attribute = '' this.funcReceiverType = '' + this.funcLocStart = undefined + this.funcLocEnd = undefined } } diff --git a/src/engine/analyzer/common/exception-handler.ts b/src/engine/analyzer/common/exception-handler.ts index 55f8a234..965f0139 100644 --- a/src/engine/analyzer/common/exception-handler.ts +++ b/src/engine/analyzer/common/exception-handler.ts @@ -1,5 +1,26 @@ const logger = require('../../../util/logger')(__filename) +interface ErrorStats { + parseErrors: number + nodeErrors: number + checkerErrors: number + otherErrors: number +} + +let errorStats: ErrorStats = { parseErrors: 0, nodeErrors: 0, checkerErrors: 0, otherErrors: 0 } + +function incrementErrorStat(category: keyof ErrorStats): void { + errorStats[category]++ +} + +function getErrorStats(): ErrorStats { + return { ...errorStats } +} + +function clearErrorStats(): void { + errorStats = { parseErrors: 0, nodeErrors: 0, checkerErrors: 0, otherErrors: 0 } +} + let totalErrors: any[] /** * @@ -26,6 +47,7 @@ function handleException(error: any, infoMsg: any, errorMsg: any): void { */ function clearTotalErrorsExceptionHandler(): void { totalErrors = [] + clearErrorStats() } /** @@ -38,10 +60,18 @@ function outputTotalErrorsExceptionHandler(): void { logger.info(error.error) } } + // 输出分类错误统计 + const stats = getErrorStats() + const totalCount = stats.parseErrors + stats.nodeErrors + stats.checkerErrors + stats.otherErrors + if (totalCount > 0) { + logger.info(`Error statistics: parse=${stats.parseErrors}, node=${stats.nodeErrors}, checker=${stats.checkerErrors}, other=${stats.otherErrors}, total=${totalCount}`) + } } export { handleException, clearTotalErrorsExceptionHandler as clearTotalErrors, outputTotalErrorsExceptionHandler as outputTotalErrors, + incrementErrorStat, + getErrorStats, } diff --git a/src/engine/analyzer/common/initializer.ts b/src/engine/analyzer/common/initializer.ts index 71a155fe..0a3deca0 100644 --- a/src/engine/analyzer/common/initializer.ts +++ b/src/engine/analyzer/common/initializer.ts @@ -1,5 +1,6 @@ import { shallowCopyValue } from '../../../util/clone-util' import type Unit from './value/unit' +import { AstRefList } from './value/ast-ref-list' const _ = require('lodash') const Scope = require('./scope') @@ -189,6 +190,9 @@ function resolveClassInheritance(fclos: Unit): void { if (fieldName === '_CTOR_') { superValue.ast.node = v_copy.ast?.node superValue.ast.fdef = v_copy.ast.fdef + if (!superValue.overloaded) { + superValue.overloaded = new AstRefList(() => superValue.getASTManager()) + } superValue.overloaded.push(fdef) } diff --git a/src/engine/analyzer/common/memSpace.ts b/src/engine/analyzer/common/memSpace.ts index cd1348e7..4a424a33 100644 --- a/src/engine/analyzer/common/memSpace.ts +++ b/src/engine/analyzer/common/memSpace.ts @@ -11,6 +11,7 @@ const { const AstUtil = require('../../../util/ast-util') const varUtil = require('../../../util/variable-util') const { handleException } = require('./exception-handler') +const { getGlobalSymbolTable } = require('../../../util/global-registry') import type UnitType from './value/unit' type FilterFn = ((scope: UnitType) => boolean) | null @@ -48,13 +49,27 @@ class MemSpace extends Scope { } /** - * calculate the indices of an object access; resolve non-atomic expressions - * for instance, expression A[x][y] will be converted into A[v1][v2] where v1 and v2 are values of x and y respectively - * need to calculate the index value upon the current scope - * @param scope - * @param node - * @param state - * @returns {*} + * 解析 lvalue 表达式节点，返回一个可被 taint 追踪的地址对象（Value 实例）或原 AST node。 + * + * ⚠️ 返回类型不统一（历史鸭子类型设计）： + * - Identifier / Parameter — 返回 SymbolValue（sid=``） + * - Literal — 返回 SymbolValue（sid=``） + * - MemberAccess — 返回 MemberExprValue；若 index 与 object 皆无变化则短路返回原 node + * - ThisExpression / SuperExpression — 返回 SymbolValue + * - union（node.vtype） — 返回 UnionValue + * - VariableDeclaration / DereferenceExpression — 返回 SymbolValue + * - 其他 — 走 processInstruction 兜底，返回其结果 + * + * 下游（saveVarInScopeRec）既读 AST 字段（.type / .name / .value）又读 Value 字段 + * （.vtype === 'union'），两种结构共享字段名靠鸭子类型运行，属于设计债， + * 未来 Value 重设计任务中处理。 + * + * ⚠️ 非幂等：对 resolveIndices 的结果再次调用会再生成一个 SymbolValue（因为 + * SymbolValue 在构造时 spread 了原 node，保留了 node.type='Identifier' 等字段）。 + * 同一 node 不要重复 resolve，调用链参见 saveVarInScope / saveVarInCurrentScope 注释。 + * + * @param node AST node 或 Value 实例（字符串也会被包成 IdentifierRefValue） + * @returns SymbolValue | MemberExprValue | UnionValue | 原 AST node | processInstruction 结果 */ resolveIndices(scope: UnitType, node: any, state: any): any { if (!node) return node @@ -70,6 +85,9 @@ class MemSpace extends Scope { let prop: any if (!node.computed) { prop = index = node.property + } else if (node.property?.type === 'Noop') { + // 保留 Noop，让 saveVarInScopeRec 处理数组追加（PHP $arr[] = value） + prop = index = node.property } else if (node.type === 'Literal') { prop = index = node.property } else { @@ -306,36 +324,54 @@ class MemSpace extends Scope { //* ***************************** Write Operations ************************************* /** - * write the value of a variable into the scope; search the right scope when neccessary + * 写变量到正确的作用域（必要时沿作用域链向上找 def scope） + * + * 调用链：saveVarInScope → saveVarInCurrentScope（做 resolveIndices）→ saveVarInScopeRec。 + * saveVarInCurrentScope 会对 node 做 resolveIndices，此处不再提前 resolve，避免重复分配 SymbolValue。 + * * @param scope - * @param node: AST node - * @param value: value to be stored - * @param state: extra analysis data - * @param node - * @param value - * @param state - * @param oldVal - * @returns {*} + * @param node AST node + * @param value 待写入的 Value + * @param state 分析状态 + * @param oldVal 旧值（用于继承 rtype） */ saveVarInScope(scope: UnitType, node: any, value: UnitType, state: any, oldVal: UnitType | null = null): any { if (!value.rtype && oldVal && oldVal.rtype) value.rtype = oldVal.rtype - const resolvedNode = this.resolveIndices(scope, node, state) - const defscope = this.getDefScope(scope, node) if (state && state.brs) state.br_index = 0 - return this.saveVarInCurrentScope(defscope, resolvedNode, value, state) + return this.saveVarInCurrentScope(defscope, node, value, state) } /** - * write the value of a variable into the current scope - * @param scope - * @param node - * @param value - * @param state - * @returns {*} + * 写变量到当前作用域（入口点） + * + * 所有直接调用点（go/python/php/java/js-analyzer 等）都传入原始 AST node。 + * + * 入口对 lvalue 做分派： + * - 简单 lvalue（Identifier / Parameter / Literal）：直接下发 AST node。 + * 下游 saveVarInScopeRec 只读 node.type / node.name / node.value， + * AST node 本身就有这些字段，无需经过 resolveIndices 的 SymbolValue 包装， + * 跳过可省一次 `new SymbolValue(..., { sid, ...node })` 分配。 + * - 复杂 lvalue（MemberAccess / union / This / Super / VariableDeclaration / + * DereferenceExpression / 其他）：走 resolveIndices 转为 + * MemberExprValue / UnionValue / SymbolValue，保证 MemberExprValue 的 + * qid 链完整以及下游对 Value 接口的依赖。 + * + * resolveIndices 本身保持 release 语义不变（所有分支永远返回 Value）。 + * + * @param scope 目标 scope + * @param node AST node + * @param value 待写入的 Value + * @param state 分析状态 */ saveVarInCurrentScope(scope: UnitType, node: any, value: UnitType, state: any): any { + if (node && (node.type === 'Identifier' || node.type === 'Parameter' || node.type === 'Literal')) { + if (value && node.rtype && !value.rtype) { + value.rtype = node.rtype + } + return this.saveVarInScopeRec(scope, node, value, state) + } const resolvedNode = this.resolveIndices(scope, node, state) if (value && resolvedNode?.rtype && !value?.rtype) { value.rtype = resolvedNode.rtype @@ -433,6 +469,17 @@ class MemSpace extends Scope { saveVarInScopeDirect(scope, node.value, value, state) return } + case 'Noop': { + // 数组追加（PHP $arr[] = value）：计算下一个数字索引 + const fields = scope.value || {} + let maxIdx = -1 + for (const key of Object.keys(fields)) { + const n = parseInt(key, 10) + if (!isNaN(n) && n > maxIdx) maxIdx = n + } + saveVarInScopeDirect(scope, String(maxIdx + 1), value, state) + return + } } // other cases, e.g. the identity is symbolic @@ -560,6 +607,17 @@ class MemSpace extends Scope { if (!node) { return undefined } + + // MemberAccess 递归解析：当 node 本身是 MemberExprValue（如 kmm.modules）时， + // 递归先解析 object，再从 object 中取 property，避免走 fallback 创建占位符 + if (node.type === 'MemberAccess' && node.object && node.property) { + const objectVal = this._getMemberValueRec(scope, node.object, state, createIfNotExists) + if (objectVal && objectVal.type !== 'MemberAccess') { + // objectVal 已解析为实际对象，递归取 property + return this._getMemberValueDirect(objectVal, node.property, state, createIfNotExists, stack + 1, new Set()) + } + } + switch (node.type) { case 'Identifier': case 'Literal': @@ -590,6 +648,14 @@ class MemSpace extends Scope { if (fields && _.has(fields, index)) { // todo 还需要判断当前的val 是否state匹配 val = fields[index] + // UUID 字符串解析回实际符号值 + if (val && typeof val === 'string' && val.startsWith('symuuid_')) { + const symbolTable = getGlobalSymbolTable() + const resolved = symbolTable?.get(val) + if (resolved) { + val = resolved + } + } if (val.func?.jumpLocate) { const targetVal = val.func.jumpLocate(val, qid, scope) if (targetVal) { diff --git a/src/engine/analyzer/common/memStateBVT.ts b/src/engine/analyzer/common/memStateBVT.ts index 926fa976..9b407bb9 100644 --- a/src/engine/analyzer/common/memStateBVT.ts +++ b/src/engine/analyzer/common/memStateBVT.ts @@ -32,6 +32,8 @@ function writeValueBVT(fields: any, index: any, value: any, br: any, br_index: a const oldTree = tree tree = new BVTValue('', ``, {}) tree.raw_value = oldTree + // 保留原始值的类型信息 + if (oldTree?.rtype) tree.rtype = oldTree.rtype parentBvt.setChild(pname, tree) } if (i < br.length - 1) { @@ -55,9 +57,11 @@ function writeValueBVT(fields: any, index: any, value: any, br: any, br_index: a old_value = new BVTValue(scope.qid, ``, {}) old_value.raw_value = oldValue // 直接设置 raw_value，不通过 setter } else if (old_value.vtype !== 'BVT') { - old_value = createBVT(scope.qid, br, old_value, value.ast?.node) + old_value = createBVT(scope.qid, br, old_value, value.ast?.node, index) } fields[index] = old_value + // 标记此 scope 有 BVT 字段，供 mergeLeafValues parent 链跳跃使用 + scope._hasBVTFields = true write(old_value, br, br_index, old_value, index) } else if (scope.pointerReference) { // overwrite directly @@ -74,7 +78,7 @@ function writeValueBVT(fields: any, index: any, value: any, br: any, br_index: a * @param old_value * @param node */ -function createBVT(qidPrefix: string, br: any, old_value: any, node: any): any { +function createBVT(qidPrefix: string, br: any, old_value: any, node: any, fieldIndex?: string): any { if (!br || br.length === 0) { return old_value } @@ -86,8 +90,12 @@ function createBVT(qidPrefix: string, br: any, old_value: any, node: any): any { if (node?.loc?.sourcefile && typeof node?.loc?.sourcefile === 'string') { sig = `${node.loc?.sourcefile.substring((node.loc?.sourcefile.lastIndexOf('/') || 0) + 1, node.loc?.sourcefile.lastIndexOf('.'))}_${node.loc?.start?.line}_${node.loc?.start?.column}_${node.loc?.end?.line}_${node.loc?.end?.column}` } - - return new BVTValue(qidPrefix, ``, { [currentChar]: nestedBVT }) + // 字段索引加入 sig，避免同一对象不同字段写入因共享 AST 节点位置导致 UUID 碰撞 + const indexPart = fieldIndex ? `_${fieldIndex}` : '' + const bvt = new BVTValue(qidPrefix, ``, { [currentChar]: nestedBVT }) + // 保留原始值的类型信息，供分支读取时传播 + if (old_value?.rtype) bvt.rtype = old_value.rtype + return bvt } /** @@ -122,11 +130,14 @@ function readValue(value: any, br: any, br_index: any): any { if (value.vtype) { return value } - return new SymbolValue('', { + const sv = new SymbolValue('', { sid: `${tree.sid}`, qid: `${tree.qid}`, field: value, }) + // 分支回退时保留 BVT 上保存的类型信息 + if (tree.rtype) sv.rtype = tree.rtype + return sv } return read(children[c], br, i + 1) } @@ -146,11 +157,14 @@ function readValue(value: any, br: any, br_index: any): any { if (pval.vtype) { return pval } - return new SymbolValue('', { + const sv2 = new SymbolValue('', { sid: `${tree.sid}`, qid: `${tree.qid}`, field: pval, }) + // 分支回退时保留 BVT 上保存的类型信息 + if (tree.rtype) sv2.rtype = tree.rtype + return sv2 } if (!value) return value @@ -191,15 +205,25 @@ function unionValue(v1: any, v2: any): any { } if (v1.vtype === 'union') { if (v2.vtype === 'union') { - const vs = v1.value.concat(v2.value) + // 按 uuid 去重合并两个 Union 的元素 + const seen = new Set() + const vs: any[] = [] + for (const val of v1.value) { + const uid = val?.uuid || val + if (typeof uid === 'string' && seen.has(uid)) continue + if (typeof uid === 'string') seen.add(uid) + vs.push(val) + } + for (const val of v2.value) { + const uid = val?.uuid || val + if (typeof uid === 'string' && seen.has(uid)) continue + if (typeof uid === 'string') seen.add(uid) + vs.push(val) + } return vs.length === 1 ? vs[0] : new UnionValue(vs, undefined, `${v1.qid}.`, v1.ast?.node) } const vs = v1.value.slice() - if ( - !vs.some(function (x: any) { - x === v2 - }) - ) + if (!vs.some((x: any) => x === v2)) vs.push(v2) return vs.length === 1 ? vs[0] : new UnionValue(vs, undefined, `${v1.qid}.`, v1.ast?.node) } @@ -243,17 +267,23 @@ function mergeLeafValues(scope: any, brs: any, br_index: any, parent: any, visit return vs // scope; } if (scope.vtype === 'object' || scope.vtype === 'fclos' || scope.vtype === 'scope') { - // 深度优先递归合并scope的所有children元素 + // 深度优先递归合并 scope 的所有字段 for (const field in scope.value) { - // if (field === 'parent') continue; const v = scope.value[field] if (visited.has(v)) continue scope.value[field] = mergeLeafValues(v, brs, br_index, parent, visited) } - // TODO:check以下这段逻辑，parent为什么要合并？是否有污染问题 - const parent_scope = scope.parent - if (parent_scope && !visited.has(parent_scope)) - scope.parent = mergeLeafValues(parent_scope, brs, br_index, parent, visited) + // 沿 parent 链跳跃合并：只处理 writeValueBVT 标记过的 scope（_hasBVTFields）， + // 跳过无 BVT 修改的中间 parent，避免对大型 global scope 的无效遍历。 + let p = scope.parent + while (p && !visited.has(p)) { + if (p._hasBVTFields) { + mergeLeafValues(p, brs, br_index, parent, visited) + break // 更深层的 parent 会在 mergeLeafValues(p, ...) 的递归中处理 + } + visited.add(p) // 标记已跳过，避免重复遍历 + p = p.parent + } return scope } if (Array.isArray(scope)) { diff --git a/src/engine/analyzer/common/sarif.ts b/src/engine/analyzer/common/sarif.ts index 8188aedf..38e5e5b1 100644 --- a/src/engine/analyzer/common/sarif.ts +++ b/src/engine/analyzer/common/sarif.ts @@ -134,12 +134,97 @@ function prepareTrace(locations: SarifLocation[]): any[] { ] } +/** + * 按 (sink_uri, sink_line, entrypoint) 聚合同 sink 同 ep 的多条 result， + * 把各自的 codeFlows 合并到一条 result 的 codeFlows 数组中。 + * 用途：D24 triage 发现 43% 的 SARIF result 是同 sink 不同 codeFlow 的枚举重复， + * 下游人工 triage 成本巨大；SARIF 规范允许一个 result 携带多个 codeFlows。 + * + * 聚合 key：`uri|startLine|ep.filePath::ep.functionName::ep.funcReceiverType::ep.attribute`。 + * 以下情况不聚合（按原顺序独立保留）： + * - locations 为空或缺失 physicalLocation / startLine + * - entrypoint 缺失 functionName（无法判定同 ep） + * 合并时保留第一条 result 的非 codeFlows 字段（level / rank / message / sinkInfo / + * callstack / matchedSanitizerTags），codeFlows 依原始顺序拼接且自动去重完全相同的枝。 + * @param results + */ +function dedupResultsBySinkAndEntrypoint(results: SarifResult[]): SarifResult[] { + if (!Array.isArray(results) || results.length <= 1) { + return results + } + const keyToIdx = new Map() + const seenFlowsPerKey = new Map>() + const final: SarifResult[] = [] + + for (const r of results) { + const key = buildDedupKey(r) + if (key === null) { + final.push(r) + continue + } + const existingIdx = keyToIdx.get(key) + if (existingIdx === undefined) { + keyToIdx.set(key, final.length) + final.push(r) + const seen = new Set() + for (const flow of toFlowArray(r.codeFlows)) { + seen.add(serializeFlow(flow)) + } + seenFlowsPerKey.set(key, seen) + continue + } + const existing = final[existingIdx] + if (!Array.isArray(existing.codeFlows)) { + existing.codeFlows = [] + } + const seen = seenFlowsPerKey.get(key)! + for (const flow of toFlowArray(r.codeFlows)) { + const sig = serializeFlow(flow) + if (seen.has(sig)) continue + seen.add(sig) + existing.codeFlows.push(flow) + } + } + return final +} + +function buildDedupKey(r: SarifResult): string | null { + const loc = r?.locations?.[0] + const uri = loc?.physicalLocation?.artifactLocation?.uri + const startLine = loc?.physicalLocation?.region?.startLine + const ep = r?.entrypoint + const epFuncName = ep?.functionName + if (!uri || typeof startLine !== 'number' || !epFuncName) { + return null + } + const epFilePath = ep?.filePath ?? '' + const epAttr = ep?.attribute ?? '' + const epReceiver = ep?.funcReceiverType ?? '' + return `${uri}|${startLine}|${epFilePath}::${epFuncName}::${epReceiver}::${epAttr}` +} + +function toFlowArray(codeFlows: any): any[] { + if (!codeFlows) return [] + if (Array.isArray(codeFlows)) return codeFlows + return [codeFlows] +} + +function serializeFlow(flow: any): string { + try { + return JSON.stringify(flow) + } catch (_err) { + // 极端场景下 flow 含循环引用，退化为唯一随机签名（不聚合） + return `__ref__${Math.random()}` + } +} + /** * * @param results * @param graphs */ function prepareSarifFormat(results: SarifResult[], graphs: any): Record { + const deduped = results return { runs: [ { @@ -150,7 +235,7 @@ function prepareSarifFormat(results: SarifResult[], graphs: any): Record fclos.getASTManager()) + } fclos.overloaded.push(node) return fclos } - for (let k = 0; k < fclos.overloaded.length; k++) { - const resolved = fclos.overloaded.get(k) + for (let k = 0; k < (fclos.overloaded?.length ?? 0); k++) { + const resolved = fclos.overloaded!.get(k) if (!resolved) continue const param = resolved.parameters const overloadedLen = Array.isArray(param) ? param.length : param.parameters.length @@ -227,13 +231,16 @@ class Scope { } } if (typeMatch) { - fclos.overloaded.set(k, node) + fclos.overloaded!.set(k, node) matched = true break } } } if (!matched) { + if (!fclos.overloaded) { + fclos.overloaded = new AstRefList(() => fclos.getASTManager()) + } fclos.overloaded.push(node) } fclos = lodashCloneWithTag(fclos) diff --git a/src/engine/analyzer/common/source-line.ts b/src/engine/analyzer/common/source-line.ts index 11f536b9..b0273dd0 100644 --- a/src/engine/analyzer/common/source-line.ts +++ b/src/engine/analyzer/common/source-line.ts @@ -11,6 +11,10 @@ const VariableUtil = require('../../../util/variable-util') // 全局 analyzer 引用，用于访问 sourceCodeCache let globalAnalyzer: any = null +// 无 analyzer 场景（如 dumpAllAST）共享的模块级单例 cache +// 不能每次 new 一个新 Map，否则 storeCode 写入和 getCodeByLocation 读取用的是不同实例 +const fallbackSourceCodeCache: Map = new Map() + /** * 设置全局 analyzer 实例 * @param analyzer analyzer 实例 @@ -35,9 +39,11 @@ function getSourceCodeCache(): Map { if (globalAnalyzer && globalAnalyzer.sourceCodeCache instanceof Map) { return globalAnalyzer.sourceCodeCache } - // 如果没有全局 analyzer，返回一个临时的 Map（向后兼容） + // 没有全局 analyzer 时（如 dumpAllAST），使用模块级单例 Map + // 修复：之前每次 new Map 导致 storeCode 写入和后续读取用的是不同实例， + // 使 addNodeHash 拿不到源码，走 prettyPrint fallback，与 analyzer 路径产生 hash 不一致 if (!globalAnalyzer) { - return new Map() + return fallbackSourceCodeCache } // 如果 sourceCodeCache 不是 Map，转换为 Map if ( @@ -56,7 +62,7 @@ function getSourceCodeCache(): Map { globalAnalyzer.sourceCodeCache = map return map } - return new Map() + return fallbackSourceCodeCache } diff --git a/src/engine/analyzer/common/value/ast-binding.ts b/src/engine/analyzer/common/value/ast-binding.ts index 50093690..5fd010a4 100644 --- a/src/engine/analyzer/common/value/ast-binding.ts +++ b/src/engine/analyzer/common/value/ast-binding.ts @@ -13,7 +13,7 @@ export class AstBinding { private _nodeRef: AstRef | null = null private _fdefRef: AstRef | null = null private _cdefRef: AstRef | null = null - private _declsMap: Map = new Map() + private _declsMap: Map | undefined = undefined private _owner: { getASTManager(): AstNodeManager | null } constructor(owner: { getASTManager(): AstNodeManager | null }) { @@ -53,25 +53,28 @@ export class AstBinding { set cdef(astNode: BaseNode | null | undefined) { this._cdefRef = this._toRef(astNode ?? null) } getDecl(key: string): BaseNode | null { - return this._resolve(this._declsMap.get(key) ?? null) + return this._resolve(this._declsMap?.get(key) ?? null) } setDecl(key: string, astNode: BaseNode | null | undefined): void { - if (!astNode) { this._declsMap.delete(key); return } + if (!astNode) { this._declsMap?.delete(key); return } const ref = this._toRef(astNode) - if (ref) this._declsMap.set(key, ref) + if (ref) { + if (!this._declsMap) this._declsMap = new Map() + this._declsMap.set(key, ref) + } } hasDecl(key: string): boolean { - return this._declsMap.has(key) + return this._declsMap?.has(key) ?? false } deleteDecl(key: string): void { - this._declsMap.delete(key) + this._declsMap?.delete(key) } get declKeys(): string[] { - return Array.from(this._declsMap.keys()) + return this._declsMap ? Array.from(this._declsMap.keys()) : [] } initDecls(declsObj: Record | null | undefined): void { @@ -87,6 +90,7 @@ export class AstBinding { hash = uastNode._meta?.nodehash ?? null } if (hash) { + if (!this._declsMap) this._declsMap = new Map() this._declsMap.set(key, new AstRef(hash)) } } @@ -97,7 +101,7 @@ export class AstBinding { c._nodeRef = this._nodeRef c._fdefRef = this._fdefRef c._cdefRef = this._cdefRef - c._declsMap = new Map(this._declsMap) + c._declsMap = this._declsMap ? new Map(this._declsMap) : undefined return c } } diff --git a/src/engine/analyzer/common/value/object.ts b/src/engine/analyzer/common/value/object.ts index 13d710f2..f7cb8707 100644 --- a/src/engine/analyzer/common/value/object.ts +++ b/src/engine/analyzer/common/value/object.ts @@ -58,6 +58,8 @@ export class ObjectValue extends EntityValue { if (this.taint === NULL_TAINT) this.taint = new TaintRecord(this) this.taint.markRecursive() + // ObjectValue 及子类需要 misc_ 共享语义（alias 间状态同步） + this.misc_ = {} // ObjectValue-specific properties if ('element' in finalOpts) this.element = finalOpts.element if ('uninit' in finalOpts) this.uninit = finalOpts.uninit diff --git a/src/engine/analyzer/common/value/union.ts b/src/engine/analyzer/common/value/union.ts index 13959a01..fca67eca 100644 --- a/src/engine/analyzer/common/value/union.ts +++ b/src/engine/analyzer/common/value/union.ts @@ -16,6 +16,7 @@ const astUtil = require('../../../../util/ast-util') export class UnionValue extends DataValue { set: WeakSet elements!: ValueRefList + isTuple: boolean = false raw_value: unknown @@ -223,7 +224,7 @@ export class UnionValue extends DataValue { return } - if (flatten && val instanceof UnionValue) { + if (flatten && val instanceof UnionValue && !val.isTuple) { for (const v of val.value) { this.appendValue(v, uniqueFlag, flatten) } diff --git a/src/engine/analyzer/common/value/unit.ts b/src/engine/analyzer/common/value/unit.ts index d6fbfdbc..f715c4f8 100644 --- a/src/engine/analyzer/common/value/unit.ts +++ b/src/engine/analyzer/common/value/unit.ts @@ -10,6 +10,7 @@ const { getGlobalSymbolTable, getGlobalASTManager } = require('../../../../util/ const { yasaWarning } = require('../../../../util/format-util') const QidUnifyUtil = require('../../../../util/qid-unify-util') + class Unit { // Allows subclass properties assigned via constructor opts [key: string]: any @@ -19,7 +20,7 @@ class Unit { uuid: string = '' declsNodehash: any = undefined _taint: TaintRecord | null = null - misc_: Record = {} + misc_?: Record // ===== Private fields ===== _sid: string = '' @@ -51,21 +52,18 @@ class Unit { this._field = _field ?? {} - this.misc_ = new Object() - - this._ast = new AstBinding(this) + // _ast 懒创建：只在有 decls 时提前初始化 const oldDecls = opts.decls if (oldDecls && typeof oldDecls === 'object' && !Array.isArray(oldDecls)) { - this._ast.initDecls(oldDecls) + this.ast.initDecls(oldDecls) } - this._scopeCtx = new ScopeCtx(this) + // _scopeCtx 懒创建：不再在构造函数中分配 - const getAM = () => this.getASTManager() const oldOverloaded = opts.overloaded - this.overloaded = oldOverloaded && Array.isArray(oldOverloaded) - ? AstRefList.from(oldOverloaded, getAM) - : new AstRefList(getAM) + if (oldOverloaded && Array.isArray(oldOverloaded)) { + this.overloaded = AstRefList.from(oldOverloaded, () => this.getASTManager()) + } if (opts.parent !== undefined) this.parent = opts.parent @@ -84,7 +82,7 @@ class Unit { if (opts.ast !== undefined) this.ast = opts.ast - if (opts.exports !== undefined) this._scopeCtx.exports = opts.exports + if (opts.exports !== undefined) this.scope.exports = opts.exports this._isConstructing = true @@ -344,11 +342,12 @@ class Unit { } setMisc(key: string, value: any): void { + if (!this.misc_) this.misc_ = {} this.misc_[key] = value } getMisc(key: string): any { - return this.misc_[key] + return this.misc_?.[key] } reset(): void { @@ -419,15 +418,18 @@ class Unit { } get ast(): AstBinding { - return this._ast! + if (!this._ast) this._ast = new AstBinding(this) + return this._ast } set ast(astNode: any) { - if (this._ast) this._ast.node = astNode + if (!this._ast) this._ast = new AstBinding(this) + this._ast.node = astNode } get scope(): ScopeCtx { - return this._scopeCtx! + if (!this._scopeCtx) this._scopeCtx = new ScopeCtx(this) + return this._scopeCtx } get parent(): Unit | null { return this._resolveValueRef(this._parentRef) } diff --git a/src/engine/analyzer/common/value/value-ref.ts b/src/engine/analyzer/common/value/value-ref.ts index 41069902..b6dec20b 100644 --- a/src/engine/analyzer/common/value/value-ref.ts +++ b/src/engine/analyzer/common/value/value-ref.ts @@ -8,9 +8,8 @@ export class ValueRef { readonly uuid: string - private _cached: any = null - private _directWeak: WeakRef | null = null - private _directStrong: any = null + private _directWeak?: WeakRef + private _directStrong?: any constructor(uuid: string, direct?: any) { if (!direct && (typeof uuid !== 'string' || uuid.length === 0)) { @@ -33,14 +32,14 @@ export class ValueRef { set _direct(val: any) { if (val == null) { - this._directWeak = null - this._directStrong = null + this._directWeak = undefined + this._directStrong = undefined } else if (typeof val === 'object') { this._directWeak = new WeakRef(val) - this._directStrong = null + this._directStrong = undefined } else { this._directStrong = val - this._directWeak = null + this._directWeak = undefined } } @@ -62,7 +61,7 @@ export class ValueRef { */ markRegistered(): void { if (this.uuid) { - this._directStrong = null + this._directStrong = undefined } } diff --git a/src/engine/analyzer/golang/common/go-analyzer.ts b/src/engine/analyzer/golang/common/go-analyzer.ts index 67cf49bf..41c274de 100644 --- a/src/engine/analyzer/golang/common/go-analyzer.ts +++ b/src/engine/analyzer/golang/common/go-analyzer.ts @@ -1,5 +1,6 @@ import GoTypeRelatedInfoResolver from '../../../../resolver/go/go-type-related-info-resolver' import { buildNewCopiedWithTag } from '../../../../util/clone-util' +import { AstRefList } from '../../common/value/ast-ref-list' import { BinaryExprValue } from '../../common/value/binary-expr' import type { Scope, State, Value, SymbolValue as SymbolValueType } from '../../../../types/analyzer' import type { CallExpression, VariableDeclaration, NewExpression, ThisExpression, CompileUnit, BinaryExpression, MemberAccess, Identifier, TupleExpression } from '../../../../types/uast' @@ -20,7 +21,7 @@ const { shallowCopyValue, buildNewValueInstance, lodashCloneWithTag } = require( const { valueUtil: { - ValueUtil: { Scoped, PackageValue, PrimitiveValue, UndefinedValue, SymbolValue, UnionValue }, + ValueUtil: { Scoped, PackageValue, PrimitiveValue, UndefinedValue, SymbolValue, UnionValue, ObjectValue }, }, } = require('../../common') import type { CallInfo } from '../../common/call-args' @@ -36,11 +37,13 @@ const entryPointConfig = require('../../common/current-entrypoint') const { unionAllValues } = require('../../common/memStateBVT') const constValue = require('../../../../util/constant') const { handleException } = require('../../common/exception-handler') +const { ErrorCode } = require('../../../../util/error-code') /** * */ class GoAnalyzer extends Analyzer { + /** * * @param options @@ -59,6 +62,9 @@ class GoAnalyzer extends Analyzer { this.mainEntryPoints = [] this.ruleEntrypoints = [] this.typeResolver = new GoTypeRelatedInfoResolver() + this._isSymbolInterpretPhase = false + this._methodResolveCache = {} + this.classMap = new Map() } /** @@ -73,7 +79,8 @@ class GoAnalyzer extends Analyzer { 'find no target compileUnit of the project : no go file found in source path', 'find no target compileUnit of the project : no go file found in source path' ) - process.exit(1) + process.exitCode = ErrorCode.no_valid_source_file + return } } @@ -182,7 +189,7 @@ class GoAnalyzer extends Analyzer { // 在value中查找包含'node'且node.type为'CompileUnit'的节点 const v = value as any if (v.node && typeof v.node === 'object' && v.node.type === 'CompileUnit') { - fileManager[key] = { ast: v.node } + fileManager[key] = { astNode: v.node } continue } } @@ -291,6 +298,37 @@ class GoAnalyzer extends Analyzer { } } + /** + * Go 嵌入结构体方法延迟解析：实例上找不到方法时，通过 ClassDefinition 的 SpreadElement 找嵌入类型的方法。 + * 解决文件按字母序处理时，SpreadElement 阶段嵌入类型方法尚未注册导致继承失败的问题。 + */ + _resolveEmbeddedMethod(defscope: any, methodName: string): any { + // 从实例的 sid 提取类名 + const className = defscope.sid?.split('<')?.[0]?.split('.')?.[0] + if (!className) return null + + const classDefs = this._findAllClassDefsByName(className) + for (const classDef of classDefs) { + const bodyStmts = this._getClassDefBodyStmts(classDef) + if (!bodyStmts) continue + + for (const stmt of bodyStmts) { + if (stmt.type !== 'SpreadElement') continue + const embeddedTypeName = this._extractTypeName(stmt.argument) + if (!embeddedTypeName) continue + + // 在已解析的 packages 中查找嵌入类型的 ClassDefinition + const embeddedClasses = this._findAllClassDefsByName(embeddedTypeName) + for (const embeddedClass of embeddedClasses) { + if (embeddedClass.value?.[methodName]?.ast?.fdef) { + return embeddedClass.value[methodName] + } + } + } + } + return null + } + /** * * @param scope @@ -308,6 +346,19 @@ class GoAnalyzer extends Analyzer { } } + // 拦截 make(MapType, ...) 调用，返回空 map ObjectValue，避免生成 symbol + // Go UAST 中 make() 的类型参数可能是 MapType（不在 Expr union 内），用 any 绕过类型检查 + if (node.callee?.type === 'Identifier' && (node.callee as Identifier).name === 'make') { + const typeArg = node.arguments?.[0] as any + if (typeArg?.type === 'MapType') { + const line = node.loc?.start?.line ?? 'unknown' + const mapSid = `` + const mapObj = new ObjectValue(scope.qid, { sid: mapSid }) + mapObj.rtype = typeArg + return mapObj + } + } + const fclos = this.processInstruction(scope, node.callee, state) let ret if (fclos?.vtype === 'class' && node.arguments.length === 1) { @@ -324,10 +375,19 @@ class GoAnalyzer extends Analyzer { } } + // 构建 callInfo，携带调用参数信息供 checker 做 sink 匹配 + // 仅在外部库方法（无可执行函数体）时传递 callInfo，有函数体的调用由 + // super.processCallExpression 内部 executeFdeclOrExecute 统一处理 sink 匹配，避免重复 finding + const fclosBody = fclos?.ast?.fdef?.body + const isUnresolvableCall = !fclos || fclos.vtype !== 'fclos' || !fclosBody || fclosBody.type === 'Noop' + const callInfo: CallInfo | undefined = isUnresolvableCall + ? { callArgs: this.buildCallArgs(node, argvalues, fclos) } + : undefined if (argvalues && this.checkerManager) { this.checkerManager.checkAtFunctionCallBefore(this, scope, node, state, { argvalues, fclos, + callInfo, pcond: state.pcond, entry_fclos: this.entry_fclos, einfo: state.einfo, @@ -337,6 +397,74 @@ class GoAnalyzer extends Analyzer { }) } ret = super.processCallExpression(scope, node, state) + + // CHA fallback：正常 dispatch 未生效时，通过 ClassHierarchy 查找接口实现并执行 + if ( + (this as any).classHierarchyMap && + (fclos?.vtype !== 'fclos' || this.checkFclosInInterface(fclos)) && + (!ret || ret.vtype === 'symbol') + ) { + let implementations = this.findCHAImplementations(fclos) + + // rtype fallback：fclos.parent 不是接口时，通过 receiver 的 rtype 查找接口 + if (implementations.length === 0 && node.callee?.type === 'MemberAccess') { + const methodName = node.callee.property?.name || (node.callee.property as any)?.value + if (methodName) { + // 获取 receiver 的 rtype（优先 fclos.parent.rtype，其次从 callee.object 获取） + let rtype = fclos?.parent?.rtype || fclos?._object?.rtype + if (!rtype && node.callee.object) { + const receiver = this.processInstruction(scope, node.callee.object, state) + rtype = receiver?.rtype + } + if (rtype) { + const rtypeName = rtype.type === 'Identifier' ? rtype.name + : rtype.type === 'PointerType' ? rtype.element?.name + : null + if (rtypeName) { + implementations = this.findCHAImplementationsByTypeName(rtypeName, methodName) + } + } + } + } + + if (implementations.length > 0) { + const results: any[] = [] + const executed = new Set() + + for (const implFclos of implementations) { + // 剪枝：dedup（同一 call site 不重复执行同一实现） + const implKey = implFclos.qid || implFclos.uuid + if (executed.has(implKey)) continue + executed.add(implKey) + + // 剪枝：callstack depth 超限 + if (state?.callstack?.length >= Config.maxCallstackDepth) break + + // 剪枝：Noop body 跳过 + if (implFclos.ast?.fdef?.body?.type === 'Noop') continue + + // 绑定 this 并执行 + const oldThis = implFclos._this + if (fclos?._this) implFclos._this = fclos._this + else if (typeof fclos?.getThisObj === 'function') implFclos._this = fclos.getThisObj() + + const r = this.executeCall(node, implFclos, state, scope, { + callArgs: this.buildCallArgs(node, argvalues, implFclos), + }) + implFclos._this = oldThis + + if (r && r.vtype !== 'symbol') results.push(r) + } + + // 返回值合并：单个直接返回，多个用 UnionValue + if (results.length === 1) { + ret = results[0] + } else if (results.length > 1) { + ret = new UnionValue(results) + } + } + } + if (ret && this.checkerManager) { this.checkerManager.checkAtFunctionCallAfter(this, scope, node, state, { fclos, @@ -527,6 +655,10 @@ class GoAnalyzer extends Analyzer { // if (cscope && cscope.vtype !== 'undefine') if (cscope) { initVal = this.buildNewObject(cscope?.ast.fdef, cscope, state, node, scope, INTERNAL_CALL) + // 全局变量类型推导：将声明类型写入 rtype，使 sink 匹配时能获取 calleeType + if (node.varType && initVal) { + initVal.rtype = node.varType + } } else { initVal = this.createVarDeclarationScope(id, scope) } @@ -548,7 +680,9 @@ class GoAnalyzer extends Analyzer { if (initVal?.rtype && initVal.rtype !== 'DynamicType') { const cscope = this.processInstruction(scope, initVal.rtype, state) if (cscope?.vtype === 'class' && initVal.vtype !== 'primitive') { + const savedRtype = initVal.rtype initVal = this.buildTypeObject(initVal, cscope) + if (savedRtype && !initVal.rtype) initVal.rtype = savedRtype } } initVal = SourceLine.addSrcLineInfo( @@ -573,19 +707,34 @@ class GoAnalyzer extends Analyzer { const tupleId = id as TupleExpression if (initVal.vtype === 'union') { const substates = MemState.forkStates(state, 1) - const pairs = _.floor(initVal.value.length / tupleId.elements.length) - const scopes = new Array(tupleId.elements.length) - for (let i = 0; i < tupleId.elements.length; i++) { - scopes[i] = new Array(pairs) - } - for (let i = 0; i < pairs; i++) { - for (let j = 0; j < tupleId.elements.length; j++) { - scopes[j][i] = initVal.getFieldValue(String(i * tupleId.elements.length + j)) + if (initVal.isTuple) { + // 直接 tuple：按索引 1-to-1 映射 + const minLen = Math.min(tupleId.elements.length, initVal.value.length) + for (let i = 0; i < minLen; i++) { + this.saveVarInCurrentScope(scope, tupleId.elements[i], initVal.getFieldValue(String(i)), state) + } + } else { + // union-of-returns：每个元素可能是 isTuple union 或单值，按位置提取后合并 + const leftCount = tupleId.elements.length + const perPos: any[][] = Array.from({ length: leftCount }, () => []) + for (let idx = 0; idx < initVal.value.length; idx++) { + const elem = initVal.value[idx] + if (elem && elem.isTuple && elem.vtype === 'union') { + // 某个 return 分支的 tuple，按位置提取 + for (let j = 0; j < leftCount; j++) { + perPos[j].push(j < elem.value.length ? elem.value[j] : elem) + } + } else { + // 非 tuple 值，保守分配到所有位置 + for (let j = 0; j < leftCount; j++) { + perPos[j].push(elem) + } + } + } + for (let i = 0; i < leftCount; i++) { + const union = unionAllValues(perPos[i], state) + this.saveVarInCurrentScope(scope, tupleId.elements[i], union, state) } - } - for (let i = 0; i < tupleId.elements.length; i++) { - const union = unionAllValues(scopes[i], state) - this.saveVarInCurrentScope(scope, tupleId.elements[i], union, state) } } else if (Array.isArray(initVal.value) && initVal.value.length >= 1) { const minLen = Math.min(tupleId.elements.length, initVal.value.length) @@ -744,6 +893,12 @@ class GoAnalyzer extends Analyzer { this.thisFClos = oldThisFClos } + // 注册到 classMap，供 CHA 构建 ClassHierarchy + const logicalQid = cscope.logicalQid || cscope.qid + if (logicalQid && cscope.uuid) { + this.classMap.set(logicalQid, cscope.uuid) + } + return cscope } @@ -801,6 +956,9 @@ class GoAnalyzer extends Analyzer { if (fieldName === '_CTOR_') { superValue.ast.node = v_copy.ast.fdef superValue.ast.fdef = v_copy.ast.fdef + if (!superValue.overloaded) { + superValue.overloaded = new AstRefList(() => superValue.getASTManager()) + } superValue.overloaded.push(fdef) } @@ -914,6 +1072,7 @@ class GoAnalyzer extends Analyzer { } } else { // declRetType.type !== 'TupleType' + if (!retVal.value || !retVal.value[Symbol.iterator]) return retVal for (let rawValue of retVal.value) { rawValue.rtype = fclos.ast.node.returnType if (rawValue.rtype !== 'DynamicType') { @@ -966,6 +1125,94 @@ class GoAnalyzer extends Analyzer { return this.convertRetValToObjectType(fclos, argvalues, state, node, scope, retVal) } + /** + * 检查 fclos 是否属于 interface（Go 没有 abstract class） + */ + checkFclosInInterface(fclos: any): boolean { + return !!( + fclos?.parent?.isInterface || + fclos?.ast?.fdef?.parent?._meta?.isInterface + ) + } + + /** + * 从 classHierarchyMap 查找接口方法的所有具体实现 + * 递归遍历 implementedBy 链（包含间接实现） + */ + findCHAImplementations(fclos: any): any[] { + if (!this.classHierarchyMap) return [] + + const interfaceQid = fclos.parent?.logicalQid || fclos.parent?.qid + if (!interfaceQid) return [] + + const hierarchy = this.classHierarchyMap.get(interfaceQid) + if (!hierarchy || hierarchy.implementedBy.length === 0) return [] + + const methodName = fclos.sid || fclos.name + if (!methodName) return [] + + const results: any[] = [] + const visited = new Set() + + // 递归收集所有实现类（包括间接实现） + const collectImplementors = (h: any) => { + for (const impl of h.implementedBy) { + if (visited.has(impl.type)) continue + visited.add(impl.type) + + const implMethod = impl.value?.value?.[methodName] + if (implMethod?.vtype === 'fclos' && implMethod.ast?.fdef?.body?.type !== 'Noop') { + results.push(implMethod) + } + + // 递归：实现类可能也被其他类继承 + if (impl.extendedBy?.length > 0) { + collectImplementors(impl) + } + } + } + + collectImplementors(hierarchy) + return results + } + + /** + * 通过类型名和方法名在 classHierarchyMap 中查找接口实现 + * 用于 rtype fallback：当 fclos.parent 不是接口时，通过 receiver 声明类型查找 + */ + findCHAImplementationsByTypeName(typeName: string, methodName: string): any[] { + if (!this.classHierarchyMap || !typeName || !methodName) return [] + + // 在 classHierarchyMap 中查找匹配的接口（qid 以 .typeName 结尾或等于 typeName） + for (const [qid, hierarchy] of this.classHierarchyMap as Map) { + if (hierarchy.typeDeclaration !== 'interface') continue + // 匹配：qid 末尾是 typeName（考虑包名前缀） + if (qid !== typeName && !qid.endsWith('.' + typeName)) continue + if (!hierarchy.implementedBy || hierarchy.implementedBy.length === 0) continue + + const results: any[] = [] + const visited = new Set() + + const collectImplementors = (h: any) => { + for (const impl of h.implementedBy) { + if (visited.has(impl.type)) continue + visited.add(impl.type) + const implMethod = impl.value?.value?.[methodName] + if (implMethod?.vtype === 'fclos' && implMethod.ast?.fdef?.body?.type !== 'Noop') { + results.push(implMethod) + } + if (impl.extendedBy?.length > 0) { + collectImplementors(impl) + } + } + } + + collectImplementors(hierarchy) + if (results.length > 0) return results + } + return [] + } + /** * build a type object. Record the fields and initialize their values to oldScope * @param oldScope @@ -1045,6 +1292,7 @@ class GoAnalyzer extends Analyzer { * @returns {boolean} */ symbolInterpret() { + this._isSymbolInterpretPhase = true const { entryPoints } = this const state = this.initState(this.topScope) let isFromRule = false @@ -1267,6 +1515,44 @@ class GoAnalyzer extends Analyzer { } } + /** + * 防止已 resolved 的符号值被 resolveIndices 二次处理导致 qid 损坏 + */ + saveVarInCurrentScope(scope: any, node: any, value: any, state: any): any { + if (node?.vtype && node.vtype !== 'undefine' && node?.sid?.startsWith('`, name: prop.value, type: 'Identifier', loc: prop.loc }) + resolved.property = normalized + } else if (prop?.vtype === 'symbol' && !prop.sid?.startsWith('`, name: prop.name, type: 'Identifier', loc: prop.loc }) + resolved.property = normalized + } + return resolved + } + /** * * @param scope @@ -1274,15 +1560,19 @@ class GoAnalyzer extends Analyzer { * @param state */ override processMemberAccess(scope: Scope, node: MemberAccess, state: State): SymbolValueType { - const defscope = this.processInstruction(scope, node.object, state) + // 修复 Go UAST 扁平化问题：map[obj.field] 被解析为 (map[obj]).field + // 检测：外层 computed=true，object 也是 computed=true MemberAccess，且外层 property 是 Identifier， + // 并且内层 property（也是 Identifier）的 end 列紧邻外层 property 的 start 列（.分隔符） + const effectiveNode = this._tryUnflattenMapIndex(node) ?? node + const defscope = this.processInstruction(scope, effectiveNode.object, state) if (defscope.vtype === 'union' && Array.isArray(defscope.value)) { const ret = new UnionValue(undefined, undefined, `${scope.qid}.`, node) defscope.value.forEach((defScp: any) => { - ret.appendValue(this.accessValueFromDefScope(scope, node, state, defScp)) + ret.appendValue(this.accessValueFromDefScope(scope, effectiveNode, state, defScp)) }) return ret } - return this.accessValueFromDefScope(scope, node, state, defscope) + return this.accessValueFromDefScope(scope, effectiveNode, state, defscope) } /** @@ -1310,6 +1600,24 @@ class GoAnalyzer extends Analyzer { return new UndefinedValue() } const res = this.getMemberValue(defscope, resolvedProp, state) + + // Go struct 实例方法解析：实例 _field 为空时，通过 rtype 链查找 ClassDefinition 方法 + if (this._isSymbolInterpretPhase && defscope.vtype === 'symbol' && defscope.rtype && defscope.rtype !== 'DynamicType') { + const methodFclos = this.resolveGoMethod(defscope, resolvedProp?.name) + if (methodFclos) { + return methodFclos + } + } + + // Go 嵌入结构体方法解析：实例方法未找到时，通过 ClassDefinition 的 SpreadElement 查找嵌入类型的方法 + if (this._isSymbolInterpretPhase && defscope.vtype === 'object' && resolvedProp?.name + && (!res || !res.ast?.fdef)) { + const embeddedMethod = this._resolveEmbeddedMethod(defscope, resolvedProp.name) + if (embeddedMethod) { + return embeddedMethod + } + } + if (node.object.type !== 'SuperExpression' && (res.vtype !== 'union' || !Array.isArray(res.value))) { res._this = defscope } @@ -1329,6 +1637,293 @@ class GoAnalyzer extends Analyzer { return defscope } + /** + * 检测并修复 Go UAST 扁平化问题：map[obj.field] → (map[obj]).field。 + * uast4go 将 IndexExpr(X, SelectorExpr(Y, Z)) 错误解析为： + * MemberAccess(computed=true, MemberAccess(computed=true, X, Y), Z) + * 正确语义应为： + * MemberAccess(computed=true, X, MemberAccess(computed=false, Y, Z)) + * 返回重构后的临时节点，或 null 表示不需要修复。 + */ + private _tryUnflattenMapIndex(node: MemberAccess): MemberAccess | null { + // 条件1：外层 computed=true + if (!node.computed) return null + // 条件2：外层 property 是简单 Identifier + const outerProp = node.property as any + if (!outerProp || outerProp.type !== 'Identifier') return null + // 条件3：外层 object 也是 computed=true MemberAccess + const innerNode = node.object as any + if (!innerNode || innerNode.type !== 'MemberAccess' || !innerNode.computed) return null + // 条件4：内层 property 也是简单 Identifier（不是字面量或表达式） + const innerProp = innerNode.property as any + if (!innerProp || innerProp.type !== 'Identifier') return null + // 条件5：列号验证——内层 property end 列 + 1（.分隔符）= 外层 property start 列 + const innerPropEnd = innerProp.loc?.end?.column + const outerPropStart = outerProp.loc?.start?.column + if (innerPropEnd == null || outerPropStart == null) return null + if (innerPropEnd + 1 !== outerPropStart) return null + + // 重构：MemberAccess(computed=true, X, MemberAccess(computed=false, Y, Z)) + const newInnerProp: any = { + type: 'MemberAccess', + computed: false, + object: innerNode.property, // Y（mc） + property: node.property, // Z（name） + loc: { + start: innerNode.property.loc?.start, + end: node.property.loc?.end, + }, + } + const rewritten: any = { + type: 'MemberAccess', + computed: true, + object: innerNode.object, // X（startModules） + property: newInnerProp, // mc.name + loc: node.loc, + } + return rewritten as MemberAccess + } + + /** + * 策略1：从 rtype 链中提取父 ClassDefinition，再从其字段的类型找到目标 ClassDefinition 的方法 + * 策略2：遍历 packages 查找包含该方法的非接口 ClassDefinition + * 注意：不调用 processInstruction（symbolInterpret 阶段有副作用），只做数据结构遍历 + */ + resolveGoMethod(defscope: any, methodName: string): any { + const rtype = defscope.rtype + if (!rtype || typeof rtype !== 'object') return null + + // 策略1：从 rtype 链提取字段名和父类型名，然后在 packages 中精确查找 + const fieldName = rtype.vagueType?.split('.').pop() + const parentTypeNode = rtype.definiteType + if (fieldName && parentTypeNode) { + const cacheKey = `type:${fieldName}:${methodName}` + if (cacheKey in this._methodResolveCache) return this._methodResolveCache[cacheKey] + + const resolved = this._resolveMethodViaTypeChain(parentTypeNode, fieldName, methodName) + if (resolved) { + this._methodResolveCache[cacheKey] = resolved + return resolved + } + } + + // 策略2：全局搜索兜底 + const fallbackKey = `global:${methodName}` + if (fallbackKey in this._methodResolveCache) return this._methodResolveCache[fallbackKey] + + const found = this._searchMethodInPackages(methodName) + this._methodResolveCache[fallbackKey] = found + return found + } + + /** + * 策略1（纯数据遍历，无副作用）： + * 从 PointerType/Identifier AST 节点提取父类型名 → 在 packages 中找到所有同名 ClassDefinition + * → 遍历每个候选，从 body 中查找目标字段 → 提取字段的 varType → 找到目标 ClassDefinition 的方法 + * 解决同名类型歧义：多个包定义同名 struct 时，通过字段名精确匹配正确的 ClassDefinition + */ + _resolveMethodViaTypeChain(parentTypeNode: any, fieldName: string, methodName: string): any { + const parentTypeName = this._extractTypeName(parentTypeNode) + if (!parentTypeName) return null + + const parentClassDefs = this._findAllClassDefsByName(parentTypeName) + if (parentClassDefs.length === 0) return null + + // 遍历所有同名 ClassDefinition，找到包含目标字段的那个 + for (const parentClassDef of parentClassDefs) { + const bodyStmts = this._getClassDefBodyStmts(parentClassDef) + if (!bodyStmts) continue + + let fieldTypeName: string | null = null + for (const stmt of bodyStmts) { + if (stmt.type === 'VariableDeclaration' && stmt.id?.type === 'Identifier' + && stmt.id.name === fieldName && stmt.varType) { + fieldTypeName = this._extractTypeName(stmt.varType) + break + } + } + if (!fieldTypeName) continue + + // 在 packages 中找字段类型的所有 ClassDefinition + const fieldClassDefs = this._findAllClassDefsByName(fieldTypeName) + for (const fieldClassDef of fieldClassDefs) { + // 具体类型：直接取方法 + if (!fieldClassDef.isInterface && fieldClassDef.value?.[methodName]?.ast?.fdef) { + return fieldClassDef.value[methodName] + } + + // 接口类型：提取接口方法签名，搜索匹配的具体实现 + if (fieldClassDef.isInterface) { + const implMethod = this._findInterfaceImplMethod(fieldClassDef, methodName) + if (implMethod) return implMethod + } + } + } + + // 所有候选都不满足时，全局兜底 + return this._searchMethodInPackages(methodName) + } + + /** + * 接口实现查找：从接口的 body 提取方法名列表， + * 在 packages 树中搜索具备所有这些方法（带 fdef）的非接口 ClassDefinition，返回目标方法 + */ + _findInterfaceImplMethod(interfaceClassDef: any, methodName: string): any { + const bodyStmts = this._getClassDefBodyStmts(interfaceClassDef) + if (!bodyStmts || bodyStmts.length === 0) return null + + // 提取接口声明的所有方法名 + const interfaceMethodNames: string[] = [] + for (const stmt of bodyStmts) { + const name = stmt.id?.name + if (name) interfaceMethodNames.push(name) + } + if (interfaceMethodNames.length === 0 || !interfaceMethodNames.includes(methodName)) return null + + // 在 packages 树中搜索实现了该接口全部方法的非接口 ClassDefinition + const packages = this.topScope?.context?.packages + if (!packages) return null + + let found: any = null + const visited = new Set() + + const search = (node: any, depth: number): void => { + if (depth > 15 || !node || visited.has(node) || found) return + visited.add(node) + if (!node.value || typeof node.value !== 'object' || Array.isArray(node.value)) return + + for (const key of Object.keys(node.value)) { + if (found) return + const child = node.value[key] + if (!child) continue + + // 非接口 ClassDefinition，且具备目标方法 + if (child.ast?.cdef && !child.isInterface && child.value?.[methodName]?.ast?.fdef) { + // 验证该 ClassDef 实现了接口的所有方法 + const hasAll = interfaceMethodNames.every( + (m: string) => child.value?.[m]?.ast?.fdef + ) + if (hasAll) { + found = child.value[methodName] + return + } + } + + if (child.vtype === 'object' || child.vtype === 'package' || child.vtype === 'module' || child.vtype === 'class') { + search(child, depth + 1) + } + } + } + + search(packages, 0) + return found + } + + /** + * 从 AST 类型节点提取类型名（不调用 processInstruction） + * 支持：Identifier、MemberAccess、PointerType + */ + _extractTypeName(node: any): string | null { + if (!node) return null + if (node.type === 'Identifier') return node.name + if (node.type === 'PointerType' || node.type === 'StarExpression') return this._extractTypeName(node.element || node.argument) + if (node.type === 'MemberAccess' && node.property?.name) return node.property.name + // 嵌套结构化 rtype + if (node.name) return node.name + if (node.id?.name) return node.id.name + return null + } + + /** + * 从 ClassDefinition scope 提取字段声明列表。 + * Go struct 的 cdef.body 结构不固定： + * - BlockStatement：body.body 是数组 + * - ObjectExpression：body.properties 是数组 + * - 直接数组：body 本身是数组 + */ + _getClassDefBodyStmts(classDef: any): any[] | null { + const cdef = classDef?.ast?.cdef + if (!cdef?.body) return null + + const body = cdef.body + if (Array.isArray(body)) return body + if (Array.isArray(body.body)) return body.body + if (Array.isArray(body.properties)) return body.properties + return null + } + + /** + * 在 packages 树中按类型名查找所有同名 ClassDefinition（解决同名歧义） + */ + _findAllClassDefsByName(name: string): any[] { + const cacheKey = `classDefs:${name}` + if (cacheKey in this._methodResolveCache) return this._methodResolveCache[cacheKey] + + const packages = this.topScope?.context?.packages + if (!packages) return [] + + const results: any[] = [] + const visited = new Set() + + const search = (node: any, depth: number): void => { + if (depth > 15 || !node || visited.has(node)) return + visited.add(node) + if (!node.value || typeof node.value !== 'object' || Array.isArray(node.value)) return + + for (const key of Object.keys(node.value)) { + const child = node.value[key] + if (!child) continue + + if (child.ast?.cdef && child.sid === name) { + results.push(child) + } + + if (child.vtype === 'object' || child.vtype === 'package' || child.vtype === 'module' || child.vtype === 'class') { + search(child, depth + 1) + } + } + } + + search(packages, 0) + this._methodResolveCache[cacheKey] = results + return results + } + + /** + * 遍历 packages 树查找包含目标方法（带 fdef）的非接口 ClassDefinition + */ + _searchMethodInPackages(methodName: string): any { + const packages = this.topScope?.context?.packages + if (!packages) return null + + let found: any = null + const visited = new Set() + + const search = (node: any, depth: number): void => { + if (depth > 15 || !node || visited.has(node) || found) return + visited.add(node) + if (!node.value || typeof node.value !== 'object' || Array.isArray(node.value)) return + + for (const key of Object.keys(node.value)) { + if (found) return + const child = node.value[key] + if (!child) continue + + if (child.ast?.cdef && !child.isInterface && child.value?.[methodName]?.ast?.fdef) { + found = child.value[methodName] + return + } + + if (child.vtype === 'object' || child.vtype === 'package' || child.vtype === 'module') { + search(child, depth + 1) + } + } + } + + search(packages, 0) + return found + } + /** * * @param scope diff --git a/src/engine/analyzer/golang/gin/entrypoint-collector/gin-default-entrypoint.ts b/src/engine/analyzer/golang/gin/entrypoint-collector/gin-default-entrypoint.ts index f1a940b8..200e60b1 100644 --- a/src/engine/analyzer/golang/gin/entrypoint-collector/gin-default-entrypoint.ts +++ b/src/engine/analyzer/golang/gin/entrypoint-collector/gin-default-entrypoint.ts @@ -3,7 +3,7 @@ const completeEntryPoint = require('../../../../../checker/taint/common-kit/entr export {} -const RouteRegistryProperty = ['POST', 'GET', 'DELETE', 'PUT'] +const RouteRegistryProperty = ['POST', 'GET', 'DELETE', 'PUT', 'Handle'] const RouteRegistryObject = [ '.packageManager.github.com/gin-gonic/gin.Default()', @@ -114,6 +114,53 @@ function getGinEntryPointAndSource(packageManager: any) { } } +/** 通过 rtype 判断 callee 是否为 Gin 路由注册器（Engine 或 RouterGroup） */ +function isGinRouteRegistrar(calleeObject: { rtype?: unknown }): boolean { + const rtype = calleeObject.rtype + if (!rtype) return false + // rtype 可能是字符串或对象（可能含循环引用），安全提取类型名 + let rtypeStr: string + if (typeof rtype === 'string') { + rtypeStr = rtype + } else if (typeof rtype === 'object' && rtype !== null && 'name' in rtype) { + rtypeStr = String((rtype as { name: unknown }).name) + } else { + try { + rtypeStr = JSON.stringify(rtype) + } catch { + return false + } + } + return rtypeStr.includes('gin.RouterGroup') || rtypeStr.includes('gin.Engine') +} + +/** 沿 scope 链查找标识符对应的值 */ +function lookupInScopeChain(name: string, scope: { _field?: Record; parent?: any }): unknown { + let current: { _field?: Record; parent?: any } | null = scope + while (current) { + if (current._field && name in current._field) { + return current._field[name] + } + current = current.parent ?? null + } + return null +} + +/** 从 scope 链中解析 AST 表达式（Identifier / MemberAccess）对应的运行时值 */ +function resolveAstExpr(astNode: { type?: string; name?: string; object?: any; property?: { name?: string } }, scope: any): any { + if (!astNode || !scope) return null + if (astNode.type === 'Identifier') { + return lookupInScopeChain(astNode.name ?? '', scope) + } + if (astNode.type === 'MemberAccess' && astNode.object && astNode.property?.name) { + const obj = resolveAstExpr(astNode.object, scope) + if (obj && obj._field) { + return obj._field[astNode.property.name] ?? null + } + } + return null +} + /** * 自采集路由，将注册的路由函数添加到entryPoints * @param callExpNode @@ -126,20 +173,36 @@ function collectRouteRegistry(callExpNode: any, calleeObject: any, argValues: an const routeFCloses: any[] = [] const propertyName = callExpNode.callee.property?.name const objectQid = calleeObject.qid - // TODO：后续考虑用rtype判断 + // qid 前缀匹配（原有逻辑）或 rtype 匹配（支持 RouterGroup / Engine） + const isQidMatch = RouteRegistryObject.some((ginPrefix) => objectQid?.startsWith(ginPrefix)) + const isRtypeMatch = isGinRouteRegistrar(calleeObject) if ( - RouteRegistryObject.some((ginPrefix) => objectQid?.startsWith(ginPrefix)) && + (isQidMatch || isRtypeMatch) && RouteRegistryProperty.includes(propertyName) ) { - for (const arg of argValues) { - if (arg?.vtype === 'fclos' && arg.ast?.node?.loc) { - // 避免对同一条路由注册语句重复添加 - const hash = JSON.stringify(arg.ast.node.loc) - if (!processedRouteRegistry.has(hash)) { - processedRouteRegistry.add(hash) - routeFCloses.push(arg) + for (let i = 0; i < argValues.length; i++) { + const arg = argValues[i] + if (!arg || (arg.vtype !== 'fclos' && arg.vtype !== 'symbol')) continue + if (!arg.ast?.node?.loc) continue + + // 用路由注册语句位置去重 + const hash = JSON.stringify(callExpNode.loc) + '#' + String(i) + if (processedRouteRegistry.has(hash)) continue + processedRouteRegistry.add(hash) + + // 检查 AST 中对应位置的参数是否为包装函数调用（如 WrapFD(handler)） + // 如果是，尝试从 scope 中解析实际 handler + const astArg = callExpNode.arguments?.[i] + if (astArg?.type === 'CallExpression' && astArg.arguments?.length > 0) { + // 包装函数模式：取第一个参数作为实际 handler + const innerAstArg = astArg.arguments[0] + const resolved = resolveAstExpr(innerAstArg, scope) + if (resolved?.vtype === 'fclos' && resolved.ast?.node?.loc) { + routeFCloses.push(resolved) + continue } } + routeFCloses.push(arg) } return routeFCloses } diff --git a/src/engine/analyzer/java/common/builtins/executorservice-builtins.ts b/src/engine/analyzer/java/common/builtins/executorservice-builtins.ts index 3abd2cff..81e0f7da 100644 --- a/src/engine/analyzer/java/common/builtins/executorservice-builtins.ts +++ b/src/engine/analyzer/java/common/builtins/executorservice-builtins.ts @@ -76,20 +76,25 @@ class ExecutorService extends Executor { return new UndefinedValue() } + // invokeAll 语义：每个 Callable 独立并行执行，不应共享污点状态。 + // 为每次迭代创建独立的 state 快照，防止前一个 Callable 的污点 trace 泄漏到后续 Callable。 for (const func of funcs) { + const isolatedState = _.clone(state) + isolatedState.callstack = state.callstack ? [...state.callstack] : [] + isolatedState.callsites = state.callsites ? [...state.callsites] : [] if (func.vtype === 'object' && func.members?.get('call')?.vtype === 'fclos') { // 对象实例的 call 方法：绑定 _this 指向对象实例 const callMethod = func.members.get('call') const oldThis = callMethod._this callMethod._this = func - ;(this as any).executeCall(node, callMethod, state, scope, { callArgs: (this as any).buildCallArgs(node, [], callMethod) }) + ;(this as any).executeCall(node, callMethod, isolatedState, scope, { callArgs: (this as any).buildCallArgs(node, [], callMethod) }) callMethod._this = oldThis } else if (func.members?.get('call')) { - ;(this as any).executeCall(node, func.members.get('call')!, state, scope, { callArgs: (this as any).buildCallArgs(node, [], func.members.get('call')!) }) + ;(this as any).executeCall(node, func.members.get('call')!, isolatedState, scope, { callArgs: (this as any).buildCallArgs(node, [], func.members.get('call')!) }) } else if (func.members?.get('doCall')) { - ;(this as any).executeCall(node, func.members.get('doCall')!, state, scope, { callArgs: (this as any).buildCallArgs(node, [], func.members.get('doCall')!) }) + ;(this as any).executeCall(node, func.members.get('doCall')!, isolatedState, scope, { callArgs: (this as any).buildCallArgs(node, [], func.members.get('doCall')!) }) } else if (func.vtype === 'fclos') { - ;(this as any).executeCall(node, func, state, scope, { callArgs: (this as any).buildCallArgs(node, [], func) }) + ;(this as any).executeCall(node, func, isolatedState, scope, { callArgs: (this as any).buildCallArgs(node, [], func) }) } } diff --git a/src/engine/analyzer/java/common/java-analyzer.ts b/src/engine/analyzer/java/common/java-analyzer.ts index 8a62dd0a..14b99675 100644 --- a/src/engine/analyzer/java/common/java-analyzer.ts +++ b/src/engine/analyzer/java/common/java-analyzer.ts @@ -28,6 +28,7 @@ import type { FunctionDefinition, } from '../../../../types/uast' import type { PrimitiveValue as PrimitiveValueType } from '../../../../types/value' +import type { CallInfo } from '../../common/call-args' const _ = require('lodash') const fs = require('fs') @@ -57,7 +58,6 @@ const AstUtil = require('../../../../util/ast-util') const SourceLine = require('../../common/source-line') const { checkInvocationMatchSink } = require('../../../../checker/taint/common-kit/sink-util') const { filterDataFromScope } = require('../../../../util/common-util') -import type { CallInfo } from '../../common/call-args' const { getLegacyArgValues } = require('../../common/call-args') /** @@ -94,6 +94,7 @@ class JavaAnalyzer extends Analyzer { matchSinkCacheMap: new Map(), matchSinkNoRecurseCacheMap: new Map(), matchFuncCallSourceSinkSanitizerCacheMap: new Map(), + sofaStrictMatchSinkCacheMap: new Map(), dynamicClassArray: [ 'Class', 'Thread', @@ -325,7 +326,7 @@ class JavaAnalyzer extends Analyzer { if (this.checkerManager && this.checkerManager.checkAtEndOfCompileUnit) { this.checkerManager.checkAtEndOfCompileUnit(this, null, null, state, null) } - this.fileManager[filename] = fileScope.uuid + this.fileManager[filename] = { uuid: fileScope.uuid, astNode: fileScope.ast.node } // 记录 preload 时间：累加到总 preload 时间中 this.performanceTracker.record('preProcess.preload')?.end() @@ -990,8 +991,8 @@ class JavaAnalyzer extends Analyzer { if (sofaImplList && sofaImplList.length > 0) { const methodName = fclos.sid const { sinkArray } = this.pruneInfoMap - /* 复用全局 pruning 缓存：strict 模式（checkUseDynamicFeature=false）的结果是 dynamic 模式的子集，安全复用 */ - const { matchSinkCacheMap } = this.pruneInfoMap + /* SOFA strict 匹配使用独立缓存，避免 strict=false 结果污染全局 dynamic 缓存 */ + const { sofaStrictMatchSinkCacheMap } = this.pruneInfoMap /* 获取 this 对象：fclos 可能是 symbol（Map.get() 返回值），需要安全处理 */ const thisObj = typeof fclos.getThisObj === 'function' ? fclos.getThisObj() : fclos._this @@ -1011,14 +1012,16 @@ class JavaAnalyzer extends Analyzer { if (!implFdef || implFdef.body?.type === 'Noop') continue /* 严格匹配：callgraph 中静态可达 sink 才执行 */ - const matchSink = this.checkFclosMatchSink(implFclos, [], sinkArray, matchSinkCacheMap, false) + const matchSink = this.checkFclosMatchSink(implFclos, [], sinkArray, sofaStrictMatchSinkCacheMap, false) if (!matchSink) continue strictMatchCount++ implFclos.ast.fdef = implFdef const oldThis = implFclos._this implFclos._this = thisObj - res = this.executeCall(node, implFclos, state, scope, { callArgs: this.buildCallArgs(node, argvalues, implFclos) }) + res = this.executeCall(node, implFclos, state, scope, { + callArgs: this.buildCallArgs(node, argvalues, implFclos), + }) if (res?.type === 'FunctionCall') { meetSameFuncInCallstack = true } @@ -1064,7 +1067,9 @@ class JavaAnalyzer extends Analyzer { invocation.toScope.ast.fdef = invocation.toScopeAst const oldThis = invocation.toScope._this invocation.toScope._this = fclos.getThisObj() - res = this.executeCall(node, invocation.toScope, state, scope, { callArgs: this.buildCallArgs(node, argvalues, invocation.toScope) }) + res = this.executeCall(node, invocation.toScope, state, scope, { + callArgs: this.buildCallArgs(node, argvalues, invocation.toScope), + }) if (res?.type === 'FunctionCall') { meetSameFuncInCallstack = true } @@ -1080,7 +1085,9 @@ class JavaAnalyzer extends Analyzer { fclos?.ast?.fdef?.body?.type === 'Noop' ) { if (!res) { - res = this.processLibArgToRet(node, fclos, argvalues, scope, state, { callArgs: this.buildCallArgs(node, argvalues, fclos) }) + res = this.processLibArgToRet(node, fclos, argvalues, scope, state, { + callArgs: this.buildCallArgs(node, argvalues, fclos), + }) } } else { res = this.executeCall(node, fclos, state, scope, { callArgs: this.buildCallArgs(node, argvalues, fclos) }) @@ -1121,7 +1128,9 @@ class JavaAnalyzer extends Analyzer { // execute function not found callback if (fclos._this?.members?.get('_functionNotFoundCallback_')?.vtype === 'fclos') { - this.executeCall(node, fclos._this.members.get('_functionNotFoundCallback_')!, state, scope, { callArgs: this.buildCallArgs(node, argvalues, fclos._this.members.get('_functionNotFoundCallback_')!) }) + this.executeCall(node, fclos._this.members.get('_functionNotFoundCallback_')!, state, scope, { + callArgs: this.buildCallArgs(node, argvalues, fclos._this.members.get('_functionNotFoundCallback_')!), + }) } // evaluate default equals result @@ -1139,10 +1148,14 @@ class JavaAnalyzer extends Analyzer { // execute fclos of this if (fclos?._this?.vtype === 'fclos') { if (['accept', 'apply', 'call', 'run', 'get'].includes(fclos.sid)) { - this.executeCall(node, fclos._this, state, scope, { callArgs: this.buildCallArgs(node, argvalues, fclos._this) }) + this.executeCall(node, fclos._this, state, scope, { + callArgs: this.buildCallArgs(node, argvalues, fclos._this), + }) } else if (fclos.sid === 'invoke' && argvalues.length >= 1) { fclos._this._this = argvalues[0] - this.executeCall(node, fclos._this, state, scope, { callArgs: this.buildCallArgs(node, argvalues.slice(1), fclos._this) }) + this.executeCall(node, fclos._this, state, scope, { + callArgs: this.buildCallArgs(node, argvalues.slice(1), fclos._this), + }) } } @@ -1553,7 +1566,9 @@ class JavaAnalyzer extends Analyzer { } try { - this.executeCall(overloadFuncDef, entryPoint.entryPointSymVal, state, entryPoint.scopeVal, { callArgs: this.buildCallArgs(overloadFuncDef, argValues, entryPoint.entryPointSymVal) }) + this.executeCall(overloadFuncDef, entryPoint.entryPointSymVal, state, entryPoint.scopeVal, { + callArgs: this.buildCallArgs(overloadFuncDef, argValues, entryPoint.entryPointSymVal), + }) } catch (e) { handleException( e, @@ -1626,7 +1641,13 @@ class JavaAnalyzer extends Analyzer { timeoutEntryPoint.entryPoint.entryPointSymVal, state, timeoutEntryPoint.entryPoint.scopeVal, - { callArgs: this.buildCallArgs(timeoutEntryPoint.overloadFuncDef, timeoutEntryPoint.argValues, timeoutEntryPoint.entryPoint.entryPointSymVal) } + { + callArgs: this.buildCallArgs( + timeoutEntryPoint.overloadFuncDef, + timeoutEntryPoint.argValues, + timeoutEntryPoint.entryPoint.entryPointSymVal + ), + } ) } catch (e) { handleException( @@ -1781,6 +1802,7 @@ class JavaAnalyzer extends Analyzer { * @param state * @param node * @param scope + * @param callInfo */ override buildNewObject(fdef: any, fclos: any, state: any, node: any, scope: any, callInfo: CallInfo) { const obj = super.buildNewObject(fdef, fclos, state, node, scope, callInfo) @@ -1860,7 +1882,7 @@ class JavaAnalyzer extends Analyzer { * @param sinkNum */ checkPruneSupported(entryPointNum: number, sinkNum: number) { - if (entryPointNum < Config.minEntryPointToEnablePrune || sinkNum <= 0 || Config.makeAllCG) { + if (sinkNum <= 0 || Config.makeAllCG) { return false } return !!(this.typeResolver.resolveFinish && this.ainfo?.callgraph) @@ -1965,7 +1987,12 @@ class JavaAnalyzer extends Analyzer { matchSinkCacheMap: Map, checkUseDynamicFeature: boolean ) { - if (!fclos || !fclos.invocationMap || !sinkArray) { + if (!fclos || !sinkArray) { + matchSinkCacheMap.set(fclos, false) + return false + } + const invocationMap = this.resolveInvocationMapForInherited(fclos) + if (!invocationMap) { matchSinkCacheMap.set(fclos, false) return false } @@ -1974,7 +2001,7 @@ class JavaAnalyzer extends Analyzer { return matchSinkCacheMap.get(fclos) } - for (const invocationArray of fclos.invocationMap.values()) { + for (const invocationArray of invocationMap.values()) { for (const invocation of invocationArray) { if (checkUseDynamicFeature) { for (const dynamicClass of this.pruneInfoMap.dynamicClassArray) { @@ -2005,6 +2032,33 @@ class JavaAnalyzer extends Analyzer { return false } + /** + * 对 inherited fclos 做 invocationMap fallback： + * 子类 inherited 方法的 fclos 是 cloneAlias 克隆版，clone 时 super 的 invocationMap 可能还未填充， + * 导致克隆版 invocationMap 为空，剪枝递归断链。 + * 通过 logicalQid 反查原始 class 的原始 fclos，取其 invocationMap。 + */ + private resolveInvocationMapForInherited(fclos: any): Map | undefined { + if (fclos?.invocationMap instanceof Map) { + return fclos.invocationMap + } + if (!fclos?.func?.inherited || typeof fclos.logicalQid !== 'string') { + return undefined + } + const dotIdx = fclos.logicalQid.lastIndexOf('.') + if (dotIdx <= 0) return undefined + const ownerQid = fclos.logicalQid.slice(0, dotIdx) + const methodSid = fclos.logicalQid.slice(dotIdx + 1) + const classUuid = this.classMap?.get(ownerQid) + if (!classUuid) return undefined + const classVal = this.symbolTable.get(classUuid) + const originalFclos = classVal?.members?.get(methodSid) || classVal?.value?.[methodSid] + if (originalFclos?.invocationMap instanceof Map) { + return originalFclos.invocationMap + } + return undefined + } + /** * check if fclos match any sink * @param fclos @@ -2020,7 +2074,12 @@ class JavaAnalyzer extends Analyzer { matchSinkCacheMap: Map, checkUseDynamicFeature: boolean ) { - if (!fclos || !fclos.invocationMap || !sinkArray) { + if (!fclos || !sinkArray) { + matchSinkCacheMap.set(fclos, false) + return false + } + const invocationMap = this.resolveInvocationMapForInherited(fclos) + if (!invocationMap) { matchSinkCacheMap.set(fclos, false) return false } @@ -2044,7 +2103,7 @@ class JavaAnalyzer extends Analyzer { // } const toScopeArray = [] - for (const invocationArray of fclos.invocationMap.values()) { + for (const invocationArray of invocationMap.values()) { for (const invocation of invocationArray) { if (checkUseDynamicFeature) { for (const dynamicClass of this.pruneInfoMap.dynamicClassArray) { diff --git a/src/engine/analyzer/java/spring/spring-analyzer.ts b/src/engine/analyzer/java/spring/spring-analyzer.ts index 16f4fca0..fb64356c 100644 --- a/src/engine/analyzer/java/spring/spring-analyzer.ts +++ b/src/engine/analyzer/java/spring/spring-analyzer.ts @@ -1,5 +1,7 @@ import JavaInitializer from '../common/java-initializer' import { INTERNAL_CALL } from '../../common/call-args' +import { UnionValue } from '../../common/value/union' +import type { Invocation } from '../../../../resolver/common/value/invocation' const UastSpec = require('@ant-yasa/uast-spec') const Config = require('../../../../config') @@ -581,6 +583,38 @@ class SpringAnalyzer extends JavaAnalyzer { isPrimary, }) } + /* 收集 @Handler 注解映射：识别 @Handler(value) 并建立 value → className 映射。 + @Handler 的 value 通常是常量引用（如 HandlerConstants.XXX），在 processModule 阶段 + 常量已被解析到 scope 中，通过 scope 查找获取字面量值，避免调用 processInstruction */ + if (annotations && Array.isArray(annotations) && res.logicalQid) { + for (const rawAnnotation of annotations) { + const annotationStr = AstUtil.prettyPrintAST(rawAnnotation) + if (!annotationStr?.includes('Handler')) continue + const annotation = rawAnnotation as { type?: string; body?: Array<{ type?: string }> } + if (annotation.type !== 'ScopedStatement' || !Array.isArray(annotation.body)) continue + /* ScopedStatement: body[0] 是注解类型声明，body[1+] 是注解参数值 */ + for (let i = 1; i < annotation.body.length; i++) { + const candidate = annotation.body[i] + /* 尝试解析常量引用（MemberAccess 如 HandlerConstants.XXX）*/ + const candidateStr = AstUtil.prettyPrintAST(candidate) + if (!candidateStr) continue + /* 从 scope 中查找常量值：遍历 scope 链找到常量定义 */ + let handlerValue: string | undefined + const val = this.processInstruction(scope, candidate as Expr, state) + if (val?.vtype === 'primitive' && typeof val.value === 'string') { + handlerValue = val.value + } + if (handlerValue) { + if (!this.topScope.spring.handlerAnnotationMap) { + this.topScope.spring.handlerAnnotationMap = new Map() + } + this.topScope.spring.handlerAnnotationMap.set(handlerValue, res.logicalQid) + } + break + } + break + } + } return res } @@ -719,6 +753,44 @@ class SpringAnalyzer extends JavaAnalyzer { } } } + + // 接口→实现类匹配：通过 AST supers 检查 bean 的类是否 implements targetClassName + // 只注册 classHierarchy 继承关系，不修改 AST 节点 + // 原因：修改 varType/init 会导致接口 default 方法在 callgraph 中丢失 + if (!hasFindPrimary && this.classMap && this.symbolTable && targetClassName) { + const targetShortName = targetClassName.split('.').pop() || targetClassName + let matchedBean: { className: string; isPrimary: boolean } | undefined + for (const beanValue of this.topScope.spring.beanMap.values()) { + if (!beanValue.className) { + continue + } + const classUuid = this.classMap.get(beanValue.className) + if (!classUuid) { + continue + } + const classVal = this.symbolTable.get(classUuid) + if (!classVal?.ast?.node?.supers || !Array.isArray(classVal.ast.node.supers)) { + continue + } + const implementsTarget = classVal.ast.node.supers.some( + (superAst: { name?: string }) => superAst?.name === targetShortName + ) + if (implementsTarget) { + if (beanValue.isPrimary) { + matchedBean = beanValue + break + } + if (!matchedBean) { + matchedBean = beanValue + } + } + } + if (matchedBean) { + const implClassName = matchedBean.className + this.addExtraClassHierarchyByName(implClassName, targetClassName) + return true + } + } } /** @@ -834,6 +906,157 @@ class SpringAnalyzer extends JavaAnalyzer { } } classVal.members.set(bodyAst.id.name, objVal) + + /* @Handler dispatch：对有 initApplicationContext 方法的 bean（如 HandlerFactory）， + 在 CLASS 级别覆盖 getHandler 方法，使其返回所有 @Handler 注解 bean 的联合体。 + 必须修改 memberVal（CLASS 值，被 parent/child 共享），而非 objVal（仅在当前类可见的新实例）。 + 注意：引擎的 member access 使用 scope.value[key]，不是 scope.members.get(key） */ + const handlerMap = this.topScope.spring.handlerAnnotationMap as Map | undefined + if (handlerMap && handlerMap.size > 0 && memberVal.members?.has('initApplicationContext')) { + /* 从 value 和 members 两处获取 getHandler，确保修改生效 */ + const classGetHandler = memberVal.value?.['getHandler'] || memberVal.members?.get('getHandler') + if (classGetHandler?.vtype === 'fclos') { + /* 收集所有 handler 实例联合体 */ + const handlerInstances: any[] = [] + for (const [, handlerClassName] of handlerMap) { + const handlerClassUuid = classMap.get(handlerClassName) + if (!handlerClassUuid) continue + const handlerClassVal = this.symbolTable.get(handlerClassUuid) + if (!handlerClassVal) continue + const handlerObj = newInstance(this, packageManager, handlerClassVal.qid, bodyAst) + handlerObj.injected = true + handlerObj.rtype = { type: undefined } + handlerObj.rtype.definiteType = UastSpec.identifier(handlerClassName) + handlerInstances.push(handlerObj) + } + if (handlerInstances.length > 0) { + const handlerUnion = new UnionValue( + undefined, + 'handler-dispatch-union', + `${memberVal.qid}.handler-union`, + bodyAst + ) + handlerUnion.parent = memberVal + for (const instance of handlerInstances) { + handlerUnion.appendValue(instance) + } + /* 在 CLASS 的 getHandler 上设置 runtime.execute（同时设置 value 和 members） + 同时清除 fdef，确保引擎走 runtime.execute 而非原始函数体 */ + if (!classGetHandler.runtime) classGetHandler.runtime = {} + /* 捕获 analyzer 引用，用于精确 dispatch + lazy 剪枝 */ + const analyzer = this as any + /* handlerValue → handler instance 的精确映射 */ + const handlerInstanceMap = new Map() + for (const [handlerValue, handlerClassName] of handlerMap) { + const matchingInstance = handlerInstances.find((inst: any) => + inst.rtype?.definiteType?.name === handlerClassName + ) + if (matchingInstance) { + handlerInstanceMap.set(handlerValue, matchingInstance) + } + } + let prunedUnion: any = null + classGetHandler.runtime.execute = (_fclos: any, _argvalues: any[], _state: any, _node: any, _scope: any) => { + /* 精确 dispatch：如果参数是已解析的字符串常量，直接返回对应的 handler 实例 */ + const arg = _argvalues?.[0] + if (arg?.vtype === 'primitive' && typeof arg.value === 'string') { + const exactMatch = handlerInstanceMap.get(arg.value) + if (exactMatch) { + logger.info('@Handler dispatch exact: "%s" → %s', arg.value, exactMatch.rtype?.definiteType?.name) + return exactMatch + } + } + /* 回退：lazy 剪枝，首次调用时过滤只保留 sink-reachable 的 handler */ + if (prunedUnion) return prunedUnion + const { sinkArray, sofaStrictMatchSinkCacheMap } = analyzer.pruneInfoMap || {} + if (!sinkArray || sinkArray.length === 0) { + prunedUnion = handlerUnion + return prunedUnion + } + const reachableInstances: any[] = [] + for (const instance of handlerInstances) { + const executeFclos = instance.members?.get('execute') || instance.value?.['execute'] + const doExecuteFclos = instance.members?.get('doExecute') || instance.value?.['doExecute'] + const targetFclos = doExecuteFclos || executeFclos + if (!targetFclos || !targetFclos.invocationMap) { + reachableInstances.push(instance) + continue + } + if (analyzer.checkFclosMatchSink(targetFclos, [], sinkArray, sofaStrictMatchSinkCacheMap, false)) { + reachableInstances.push(instance) + } + } + if (reachableInstances.length === 0) { + prunedUnion = handlerUnion + } else { + prunedUnion = new UnionValue( + undefined, + 'handler-dispatch-union-pruned', + `${memberVal.qid}.handler-union-pruned`, + bodyAst + ) + prunedUnion.parent = memberVal + for (const instance of reachableInstances) { + prunedUnion.appendValue(instance) + } + } + logger.info( + '@Handler dispatch lazy prune fallback: %d/%d handler sink-reachable', + reachableInstances.length, + handlerInstances.length + ) + return prunedUnion + } + if (classGetHandler.ast) classGetHandler.ast.fdef = undefined + /* 确保 value 和 members 都指向同一个有 runtime.execute 的 fclos */ + if (memberVal.value) memberVal.value['getHandler'] = classGetHandler + if (memberVal.members) memberVal.members.set('getHandler', classGetHandler) + /* 为静态剪枝注入虚拟 invocation：getHandler fclos 指向每个 handler 实例的 execute/doExecute fclos。 + 目的：checkFclosMatchSink 只递归 invocationMap 的静态 invocation，看不到 runtime.execute； + 注入后剪枝可沿 getHandler → handler.execute/doExecute 自然递归到 sink。 + calleeType/fsig/callSiteLiteral 使用特殊前缀，确保不误命中 sink 精确匹配或 dynamic feature。 */ + if (!(classGetHandler.invocationMap instanceof Map)) { + classGetHandler.invocationMap = new Map() + } + const virtualInvocations: Invocation[] = [] + for (const instance of handlerInstances) { + for (const sid of ['execute', 'doExecute']) { + const targetFclos = instance.members?.get(sid) || instance.value?.[sid] + if (targetFclos?.vtype !== 'fclos') continue + const targetFdef = + targetFclos.ast?.fdef || + (Array.isArray(targetFclos.overloaded) && targetFclos.overloaded[0]) || + targetFclos.ast?.node + virtualInvocations.push({ + callSiteLiteral: `<@Handler dispatch virtual>.${sid}`, + calleeType: '<@Handler dispatch virtual>', + fsig: `<@Handler dispatch virtual>.${sid}`, + argTypes: [], + callSite: bodyAst, + fromScope: memberVal, + fromScopeAst: memberVal.ast?.node, + toScope: targetFclos, + toScopeAst: targetFdef, + }) + } + } + if (virtualInvocations.length > 0) { + const virtualNodeHash = `${memberVal.qid}.handler-dispatch-virtual` + classGetHandler.invocationMap.set(virtualNodeHash, virtualInvocations) + } + logger.info( + '@Handler dispatch virtual invocation: CLASS [%s] getHandler 注入 %d 个虚拟 invocation (execute/doExecute handler fclos) 供静态剪枝递归', + memberVal.logicalQid || memberVal.qid, + virtualInvocations.length + ) + logger.info( + '@Handler dispatch: 在 CLASS [%s] 的 getHandler 方法上设置 runtime.execute，返回 %d 个 handler 联合体', + memberVal.logicalQid || memberVal.qid, + handlerInstances.length + ) + } + } + } } } } diff --git a/src/engine/analyzer/javascript/common/js-analyzer.ts b/src/engine/analyzer/javascript/common/js-analyzer.ts index 870a74ac..dfcae474 100644 --- a/src/engine/analyzer/javascript/common/js-analyzer.ts +++ b/src/engine/analyzer/javascript/common/js-analyzer.ts @@ -206,8 +206,8 @@ class JsAnalyzer extends Analyzer { } } else { const { filePath } = entryPoint - entryPoint.entryPointSymVal = this.symbolTable.get(this.fileManager[filePath]) - entryPoint.scopeVal = this.symbolTable.get(this.fileManager[filePath]) + entryPoint.entryPointSymVal = this.symbolTable.get(this.fileManager[filePath].uuid) + entryPoint.scopeVal = this.symbolTable.get(this.fileManager[filePath].uuid) try { this.processCompileUnit( entryPoint.scopeVal, @@ -258,7 +258,8 @@ class JsAnalyzer extends Analyzer { 'find no target compileUnit of the project : no js/ts file found in source path', 'find no target compileUnit of the project : no js/ts file found in source path' ) - process.exit(0) + process.exitCode = ErrorCode.no_valid_source_file + return } // 开始 ProcessModule 阶段：处理所有模块（分析 AST） @@ -308,7 +309,6 @@ class JsAnalyzer extends Analyzer { */ processModule(ast: any, filename: any) { if (!ast) { - process.exitCode = ErrorCode.fail_to_parse const sourceFile = filename Statistics.fileIssues[sourceFile] = 'Parsing Error' handleException( @@ -330,7 +330,7 @@ class JsAnalyzer extends Analyzer { if (m && typeof m !== 'undefined' && typeof m === 'object') { m.ast = ast this.topScope.context.modules.members.set(filename, m) - this.fileManager[filename] = m.uuid + this.fileManager[filename] = { uuid: m.uuid, astNode: m.ast.node } } return m } diff --git a/src/engine/analyzer/javascript/egg/egg-analyzer.ts b/src/engine/analyzer/javascript/egg/egg-analyzer.ts index c7e23ce5..1f7e125e 100644 --- a/src/engine/analyzer/javascript/egg/egg-analyzer.ts +++ b/src/engine/analyzer/javascript/egg/egg-analyzer.ts @@ -20,7 +20,9 @@ const { } = require('../../common') const constValue = require('../../../../util/constant') +const Config = require('../../../../config') const { handleException } = require('../../common/exception-handler') +const { ErrorCode } = require('../../../../util/error-code') const { eggSanityCheck } = require('../../../../util/framework-util') const load_mod_enum = { @@ -51,6 +53,9 @@ class EggAnalyzer extends JsAnalyzer { // prepare state this.state = this.initState(this.topScope) + // leoric ORM 适配：在 scanModules 之前初始化，使 import 能找到预置的 stub + Initializer.initLeoric(this.topScope.context.modules) + // 1st process this.scanModules(dir) @@ -140,8 +145,8 @@ class EggAnalyzer extends JsAnalyzer { } } else { const { filePath } = entryPoint - entryPoint.entryPointSymVal = this.symbolTable.get(this.fileManager[filePath]) - entryPoint.scopeVal = this.symbolTable.get(this.fileManager[filePath]) + entryPoint.entryPointSymVal = this.symbolTable.get(this.fileManager[filePath].uuid) + entryPoint.scopeVal = this.symbolTable.get(this.fileManager[filePath].uuid) try { this.processCompileUnit( entryPoint.scopeVal, @@ -401,7 +406,11 @@ class EggAnalyzer extends JsAnalyzer { // logger.debug('==========================================================\n'); // parse & process unit, attach unit to top scope - const egg_app_path = path.join(dir, 'app') + // tegg 新目录结构用 src/，传统 egg 用 app/ + let egg_app_path = path.join(dir, 'app') + if (!fs.existsSync(egg_app_path) && fs.existsSync(path.join(dir, 'src'))) { + egg_app_path = path.join(dir, 'src') + } const modules = FileUtil.loadAllFileTextGlobby( [ '**/*.(js|ts|mjs|cjs)', @@ -425,7 +434,8 @@ class EggAnalyzer extends JsAnalyzer { 'find no target compileUnit of the project : no js/ts file found in source path', 'find no target compileUnit of the project : no js/ts file found in source path' ) - process.exit(1) + process.exitCode = ErrorCode.no_valid_source_file + return false } for (const mod of modules) { this.processModuleSrc(mod.content, mod.file) @@ -504,10 +514,25 @@ class EggAnalyzer extends JsAnalyzer { * @param state */ loadPredefinedModule(scope: any, fname: any, node: any, state: any) { - // TODO modeling module more precisely - // considering two aspect: - // 1. built-in module - // 2. importing from third party package in node_modules + // tsconfig paths 别名解析：@/ → app/ + if (typeof fname === 'string' && fname.startsWith('@/')) { + const relativePath = fname.slice(2) // 去掉 @/ + const basePath = path.join(Config.maindir, 'app', relativePath) + // 尝试带扩展名查找已加载的模块 + const extensions = ['', '.ts', '.js', '.mjs', '.cjs'] + for (const ext of extensions) { + const fullPath = basePath + ext + const m = this.topScope.context.modules.members.get(fullPath) + if (m && typeof m === 'object') return m + } + // 尝试 index 文件 + const indexExts = ['/index.ts', '/index.js', '/index.mjs', '/index.cjs'] + for (const ext of indexExts) { + const fullPath = basePath + ext + const m = this.topScope.context.modules.members.get(fullPath) + if (m && typeof m === 'object') return m + } + } return super.loadPredefinedModule(scope, fname, node, state) } } diff --git a/src/engine/analyzer/javascript/egg/egg-initializer.ts b/src/engine/analyzer/javascript/egg/egg-initializer.ts index 3911acd2..f379b7f2 100644 --- a/src/engine/analyzer/javascript/egg/egg-initializer.ts +++ b/src/engine/analyzer/javascript/egg/egg-initializer.ts @@ -42,6 +42,54 @@ class EggInitializer extends JsInitializer { egg.setFieldValue('Context', ctxClass) } + /** + * leoric ORM 框架适配：预初始化 leoric 模块结构 + * 使 import { SequelizeBone } from 'leoric' 能正确解析到带 qid 的 stub， + * 从而让 this.driver.query() 在 Bone 子类中匹配 sink 规则 leoric.MysqlDriver.query + */ + static initLeoric(moduleManager: any) { + const leoric = new Scoped(moduleManager.qid, { + parent: moduleManager, + sid: 'leoric', + }) + moduleManager.setFieldValue('leoric', leoric) + + // MysqlDriver 类（sink 目标：leoric.MysqlDriver.query） + const mysqlDriverClass = new Scoped(leoric.qid, { + vtype: 'class', + parent: leoric, + sid: 'MysqlDriver', + }) + mysqlDriverClass.ast = { fdef: { type: 'ClassDefinition', body: [] } } + const queryMethod = new ObjectValue(mysqlDriverClass.qid, { + parent: mysqlDriverClass, + sid: 'query', + }) + mysqlDriverClass.setFieldValue('query', queryMethod) + leoric.setFieldValue('MysqlDriver', mysqlDriverClass) + + // Bone 基类：静态属性 driver 指向 MysqlDriver + const boneClass = new Scoped(leoric.qid, { + vtype: 'class', + parent: leoric, + sid: 'Bone', + }) + boneClass.ast = { fdef: { type: 'ClassDefinition', body: [] } } + boneClass.setFieldValue('driver', mysqlDriverClass) + leoric.setFieldValue('Bone', boneClass) + + // SequelizeBone 继承 Bone，同样持有 driver + const sequelizeBoneClass = new Scoped(leoric.qid, { + vtype: 'class', + parent: leoric, + sid: 'SequelizeBone', + }) + sequelizeBoneClass.ast = { fdef: { type: 'ClassDefinition', body: [] } } + sequelizeBoneClass.super = boneClass + sequelizeBoneClass.setFieldValue('driver', mysqlDriverClass) + leoric.setFieldValue('SequelizeBone', sequelizeBoneClass) + } + /** * builtin variables and constants for the top global * @param global diff --git a/src/engine/analyzer/javascript/egg/entrypoint-collector/egg-http.ts b/src/engine/analyzer/javascript/egg/entrypoint-collector/egg-http.ts index 28dec547..2dd6dda3 100644 --- a/src/engine/analyzer/javascript/egg/entrypoint-collector/egg-http.ts +++ b/src/engine/analyzer/javascript/egg/entrypoint-collector/egg-http.ts @@ -71,7 +71,7 @@ function getEggHttpEntryPointsAndSources(fileManager: FileManager, analyzer: any continue } EggRouterVisitor.routerList = [] - astUtil.visit(analyzer.symbolTable.get(fileManager[routerFile]).ast?.node, EggRouterVisitor) + astUtil.visit(fileManager[routerFile].astNode, EggRouterVisitor) uastUrlInfoList.push(...EggRouterVisitor.routerList) } if (uastUrlInfoList.length <= 0) { @@ -87,7 +87,7 @@ function getEggHttpEntryPointsAndSources(fileManager: FileManager, analyzer: any uastUrlInfo.relativePath = filePath.indexOf('/app/') !== -1 ? filePath.slice(filePath.indexOf('/app/')) : filePath EggMethodVisitor.uastUrlInfo = uastUrlInfo - astUtil.visit(analyzer.symbolTable.get(fileManager[filePath]).ast?.node, EggMethodVisitor) + astUtil.visit(fileManager[filePath].astNode, EggMethodVisitor) } } } @@ -136,7 +136,7 @@ function calcRouterFileList(fileManager: FileManager, analyzer: any): string[] { const routerFileList: string[] = [] for (const file of Object.getOwnPropertyNames(fileManager)) { - const codeContent = astUtil.prettyPrintAST(analyzer.symbolTable.get(fileManager[file]).ast?.node) + const codeContent = astUtil.prettyPrintAST(fileManager[file].astNode) for (const method of httpMethodList) { if (codeContent.includes(`.${method}(`)) { routerFileList.push(file) diff --git a/src/engine/analyzer/php/common/builtins/php-builtins.ts b/src/engine/analyzer/php/common/builtins/php-builtins.ts new file mode 100644 index 00000000..f1247f8f --- /dev/null +++ b/src/engine/analyzer/php/common/builtins/php-builtins.ts @@ -0,0 +1,81 @@ +/** + * PHP 内置函数 taint passthrough 注册 + * + * PHP 内置函数（json_decode、base64_decode 等）没有函数体（fdef）， + * 引擎在 executeCall 时返回无 taint 的 CallExprValue，导致 taint 断链。 + * + * 此模块为这些函数注册 runtime.execute，实现 taint passthrough： + * 如果任意输入参数带 taint，则返回值也带 taint。 + */ +import { FunctionValue } from '../../../common/value/function' +import { SymbolValue } from '../../../common/value/symbolic' +import type { Scoped } from '../../../common/value/scoped' +import type { State } from '../../../../../types/analyzer' + +/** + * 通用 taint passthrough 执行器 + * 将输入参数的 taint 传播到返回值 + */ +function createPassthroughExecute(name: string) { + return function passthroughExecute( + this: any, + _fclos: FunctionValue, + argvalues: any[], + _state: State, + node: any, + _scope: any + ): any { + const resultQid = `.${name}` + const result = new SymbolValue(resultQid, { + sid: `${name}_result`, + qid: `${resultQid}.result`, + }) + + // 传播所有输入参数的 taint 到返回值（对齐 processLibArgToRet 行为） + let isTainted = false + for (const arg of argvalues) { + if (arg?.taint?.isTaintedRec) { + isTainted = true + result.taint?.propagateFrom(arg) + } + } + if (isTainted) { + result.taint?.markSource() + } + // 将参数存入 misc_，使 hasTagRec 迭代时能追踪到 taint 参数 + if (argvalues.length > 0 && result.setMisc) { + result.setMisc('pass-in', argvalues) + } + + return result + } +} + +/** + * 需要显式 taint passthrough 的 PHP 内置函数 + * + * 注意：只注册引擎 processLibArgToRet 默认路径无法正确传播的函数。 + * sprintf/substr/array_filter/reset 等引擎默认已能正确传播 taint， + * 不要在此注册，否则会覆盖默认路径导致 taint 断链。 + */ +const PASSTHROUGH_FUNCTIONS: string[] = [ + // 暂为空——当前引擎默认的 processLibArgToRet 已能处理所有 PHP 内置函数的 taint 传播。 + // 仅在发现具体函数的 taint 断链时，才添加到此列表。 +] + +/** + * 在 topScope 中注册 PHP 内置函数的 taint passthrough + * + * 在 preProcess 后、startAnalyze 前调用 + */ +export function initPhpBuiltins(topScope: Scoped): void { + for (const funcName of PASSTHROUGH_FUNCTIONS) { + const builtinQid = `${topScope.qid}.` + const fv = new FunctionValue(builtinQid, { + sid: funcName, + qid: `${builtinQid}.${funcName}`, + }) + fv.runtime = { execute: createPassthroughExecute(funcName) } + topScope.value[funcName] = fv + } +} diff --git a/src/engine/analyzer/php/common/php-analyzer.ts b/src/engine/analyzer/php/common/php-analyzer.ts new file mode 100644 index 00000000..dd007c82 --- /dev/null +++ b/src/engine/analyzer/php/common/php-analyzer.ts @@ -0,0 +1,2141 @@ +/* eslint-disable @typescript-eslint/no-require-imports */ +const path = require('path') +const fs = require('fs-extra') +const Analyzer: typeof import('../../common/analyzer').Analyzer = require('../../common/analyzer') +const CheckerManager = require('../../common/checker-manager') +const BasicRuleHandler = require('../../../../checker/common/rules-basic-handler') +const Parser = require('../../../parser/parser') +const PhpAstBuilder = require('../../../parser/php/php-ast-builder') +const FileUtil = require('../../../../util/file-util') +const AstUtil = require('../../../../util/ast-util') +const logger: import('../../../../util/logger').Logger = require('../../../../util/logger')(__filename) +const { ErrorCode } = require('../../../../util/error-code') +const Statistics = require('../../../../util/statistics') +const config = require('../../../../config') +const ScopeClass = require('../../common/scope') +const constValue = require('../../../../util/constant') +const EntryPointConfig = require('../../common/current-entrypoint') +const { handleException } = require('../../common/exception-handler') + +const { + valueUtil: { + ValueUtil: { Scoped, ObjectValue, PrimitiveValue, UndefinedValue, VoidValue }, + }, +} = require('../../common') + +const MemState = require('../../common/memState') +const Scope = require('../../common/scope') +const StateUtil = require('../../../util/state-util') +const Uuid = require('node-uuid') +const Config = require('../../../../config') +const { filterDataFromScope } = require('../../../../util/common-util') +const _ = require('lodash') + +/** + * PHP 语言分析器 + * 参照 JsAnalyzer 最小实现，支持单文件和项目分析 + */ +class PhpAnalyzer extends Analyzer { + /** 跨文件模块 scope 缓存：filename → modClos，用于 symbolInterpret 阶段查找跨文件函数/类定义 */ + private moduleScopes = new Map() + + /** 函数静态变量持久化存储：函数全限定名 → (变量名 → 值) */ + private staticVarMap = new Map>() + + /** $GLOBALS 超全局数组共享存储：key → 值 */ + private globalsMap = new Map() + + /** 引用传参绑定栈：函数调用期间暂存 by-ref 参数 → 调用方变量的映射 */ + private _byRefBindings: Array<{ paramName: string; callerArgNode: any; callerScope: any }> = [] + + /** + * @param options - 分析选项 + */ + constructor(options: any) { + const checkerManager = new CheckerManager( + options, + options.checkerIds, + options.checkerPackIds, + options.printers, + BasicRuleHandler + ) + super(checkerManager, options) + this.options = options + this.mainEntryPoints = [] + this.sourceScope = { + complete: false, + value: [], + } + } + + /** + * 单文件预处理：解析并处理单个 PHP 文件 + * @param source - 源代码内容 + * @param fileName - 文件名 + */ + async preProcess4SingleFile(source: any, fileName: any) { + this.initTopScope() + this.state = this.initState(this.topScope) + + // 确保 PHP parser 异步初始化完成 + await PhpAstBuilder.ensureInitialized() + + // 解析源代码为 AST + this.performanceTracker.start('preProcess.parseCode') + const { options } = this + options.sourcefile = fileName + this.sourceCodeCache.set(fileName, source.split(/\n/)) + this.uast = Parser.parseSingleFile(fileName, options, this.sourceCodeCache) + this.performanceTracker.end('preProcess.parseCode') + + if (this.uast) { + this.initModuleScope(this.uast, fileName) + + // 处理已解析的 AST + this.performanceTracker.start('preProcess.processModule') + this.processModule(this.uast, fileName) + this.performanceTracker.end('preProcess.processModule') + } + } + + /** + * 预处理阶段：扫描模块并解析代码 + * @param dir - 项目目录 + */ + async preProcess(dir: any) { + await this.scanModules(dir) + } + + /** + * 扫描模块：使用统一的 parseProject 接口 + * @param dir - 项目目录 + */ + async scanModules(dir: any) { + const PARSE_CODE_STAGE = 'preProcess.parseCode' + const PROCESS_MODULE_STAGE = 'preProcess.processModule' + + // 确保 PHP parser 异步初始化完成 + await PhpAstBuilder.ensureInitialized() + + this.performanceTracker.start(PARSE_CODE_STAGE) + const astMap = await Parser.parseProject(dir, this.options, this.sourceCodeCache) + this.performanceTracker.end(PARSE_CODE_STAGE) + + if (!astMap) { + handleException( + null, + 'PhpAnalyzer.scanModules: parseProject 返回 null', + 'PhpAnalyzer.scanModules: parseProject returned null' + ) + return + } + + const fileCount = Object.keys(astMap).length + if (fileCount === 0) { + handleException( + null, + '未找到 PHP 源文件', + 'find no target compileUnit of the project: no php file found in source path' + ) + process.exitCode = ErrorCode.no_valid_source_file + return + } + + this.performanceTracker.start(PROCESS_MODULE_STAGE) + for (const filename in astMap) { + const ast = astMap[filename] + if (ast) { + this.processModule(ast, filename) + } + } + this.performanceTracker.end(PROCESS_MODULE_STAGE) + } + + /** + * 处理模块 AST + * @param ast - AST 节点 + * @param filename - 文件名 + * @returns 模块导出值 + */ + processModule(ast: any, filename: any) { + if (!ast) { + Statistics.fileIssues[filename] = 'Parsing Error' + handleException( + null, + `PhpAnalyzer.processModule: ${filename} 解析失败`, + `Error occurred in PhpAnalyzer.processModule: ${filename} parse error` + ) + return + } + let m = this.topScope.context.modules.members.get(filename) + if (m && typeof m === 'object') return m + + // 初始化模块作用域 + const modClos = this.initModuleScope(ast, filename) + this.topScope.context.modules.members.set(filename, modClos.getFieldValue('module.exports')) + m = this.processModuleDirect(ast, filename, modClos) + // 存储模块 scope，供 symbolInterpret 阶段跨文件查找函数/类定义 + this.moduleScopes.set(filename, modClos) + if (m && typeof m !== 'undefined' && typeof m === 'object') { + m.ast = ast + this.topScope.context.modules.members.set(filename, m) + this.fileManager[filename] = { uuid: m.uuid, astNode: m.ast.node } + } + return m + } + + /** + * 初始化模块作用域 + * @param node - AST 节点 + * @param file - 文件路径 + * @returns 模块闭包 + */ + override initModuleScope(node: any, file: any) { + if (!file) return + const prefix = file.substring(config.maindirPrefix?.length) + const lastDotIndex = prefix.lastIndexOf('.') + const result = lastDotIndex >= 0 ? prefix.substring(0, lastDotIndex) : prefix + const modClos = new Scoped('', { + sid: result, + parent: this.topScope, + decls: {}, + ast: node, + }) + modClos.ast.fdef = node + ;(modClos as any)._this = modClos + + const mod = new ObjectValue(modClos.qid, { sid: 'module', parent: modClos }) + modClos.value.module = mod + const exp = new ObjectValue(modClos.qid, { sid: 'module.exports', parent: modClos }) + mod.value.exports = exp + modClos.value.exports = exp + return modClos + } + + /** + * 直接处理模块 + * @param node - AST 节点 + * @param filename - 文件名 + * @param modClos - 模块闭包 + * @returns 模块导出值 + */ + processModuleDirect(node: any, filename: any, modClos: any) { + if (!node || node.type !== 'CompileUnit') { + handleException( + null, + `节点类型应为 CompileUnit，但实际为 ${node.type}`, + `node type should be CompileUnit, but ${node.type}` + ) + return undefined + } + modClos = modClos || this.initModuleScope(node, filename) + + this.entry_fclos = modClos + this.thisFClos = modClos + + const state = this.initState(modClos) + this.processInstruction(modClos, node, state) + + const moduleExports = modClos.getFieldValue('module.exports') + if (this.checkerManager && this.checkerManager.checkAtEndOfCompileUnit) { + this.checkerManager.checkAtEndOfCompileUnit(this, null, null, state, null) + } + return moduleExports + } + + /** + * 分析开始阶段：触发 checker 回调后，合并 mainEntryPoints 到 entryPoints + * 参照 GoAnalyzer.startAnalyze：checker 在 checkAtStartOfAnalyze 中设置 mainEntryPoints， + * 然后此处合并到 this.entryPoints 供 symbolInterpret 使用 + */ + override startAnalyze() { + // 注册 PHP 内置函数 taint passthrough（json_decode/base64_decode 等） + const { initPhpBuiltins } = require('./builtins/php-builtins') + initPhpBuiltins(this.topScope) + + if (this.checkerManager && this.checkerManager.checkAtStartOfAnalyze) { + this.checkerManager.checkAtStartOfAnalyze(this, null, null, null, null) + } + if (this.mainEntryPoints && Array.isArray(this.mainEntryPoints) && this.mainEntryPoints.length > 0) { + this.entryPoints = [...this.mainEntryPoints, ...this.entryPoints] + } + } + + /** + * 符号解释阶段 + */ + symbolInterpret() { + const { entryPoints } = this + const state = this.initState(this.topScope) + if (!entryPoints || entryPoints.length === 0) { + logger.info('[symbolInterpret]：EntryPoints are not found') + return true + } + const hasAnalysised: string[] = [] + for (const entryPoint of entryPoints) { + this.symbolTable.clear() + if (entryPoint.type === constValue.ENGIN_START_FUNCALL) { + const key = `${entryPoint.filePath}.${entryPoint.functionName}/${entryPoint?.entryPointSymVal?.qid}#${entryPoint.entryPointSymVal.ast.node.parameters}.${entryPoint.attribute}` + if (hasAnalysised.includes(key)) { + continue + } + hasAnalysised.push(key) + EntryPointConfig.setCurrentEntryPoint(entryPoint) + logger.info('EntryPoint [%s.%s] is executing', entryPoint.filePath, entryPoint.functionName) + + const argValues: any[] = [] + for (const param of entryPoint.entryPointSymVal?.ast?.node?.parameters || []) { + argValues.push(this.processInstruction(entryPoint.entryPointSymVal, param, state)) + } + + // 在参数值创建后再触发 Before hook，避免 taint 被后续 processInstruction 覆盖 + this.checkerManager.checkAtSymbolInterpretOfEntryPointBefore(this, null, null, null, null) + + try { + this.executeCall( + entryPoint.entryPointSymVal?.ast?.node, + entryPoint.entryPointSymVal, + state, + entryPoint.scopeVal, + { callArgs: this.buildCallArgs(entryPoint.entryPointSymVal?.ast?.node, argValues, entryPoint.entryPointSymVal) } + ) + } catch (e) { + handleException( + e, + `[${entryPoint.entryPointSymVal?.ast?.node?.id?.name} symbolInterpret 失败`, + `[${entryPoint.entryPointSymVal?.ast?.node?.id?.name} symbolInterpret failed` + ) + } + this.checkerManager.checkAtSymbolInterpretOfEntryPointAfter(this, null, null, null, null) + } else if (entryPoint.type === constValue.ENGIN_START_FILE_BEGIN) { + const key = `fileBegin:${entryPoint.filePath}.${entryPoint.attribute}` + if (hasAnalysised.includes(key)) { + continue + } + hasAnalysised.push(key) + EntryPointConfig.setCurrentEntryPoint(entryPoint) + logger.info('EntryPoint [%s] is executing', entryPoint.filePath) + if (entryPoint.entryPointSymVal && entryPoint.scopeVal) { + try { + this.processCompileUnit( + entryPoint.scopeVal, + entryPoint.entryPointSymVal?.ast?.node, + this.initState(this.topScope) + ) + } catch (e) { + handleException( + e, + `[${entryPoint.entryPointSymVal?.ast?.node?.loc?.sourcefile} symbolInterpret 失败`, + `[${entryPoint.entryPointSymVal?.ast?.node?.loc?.sourcefile} symbolInterpret failed` + ) + } + } else { + const { filePath } = entryPoint + entryPoint.entryPointSymVal = this.symbolTable.get(this.fileManager[filePath].uuid) + entryPoint.scopeVal = this.symbolTable.get(this.fileManager[filePath].uuid) + try { + this.processCompileUnit( + entryPoint.scopeVal, + entryPoint.entryPointSymVal?.ast?.node, + this.initState(this.topScope) + ) + } catch (e) { + handleException( + e, + `[${entryPoint.entryPointSymVal?.ast?.node?.loc?.sourcefile} symbolInterpret 失败`, + `[${entryPoint.entryPointSymVal?.ast?.node?.loc?.sourcefile} symbolInterpret failed` + ) + } + } + } + } + return true + } + + /** + * 从 ImportExpression 节点解析 PHP 文件路径 + * 处理 __DIR__ . '/file.php'、相对路径、绝对路径等 + */ + private resolvePhpImportPath(node: any): string | null { + const fromNode = node.from || node + const fromValue = fromNode?.value + + // 静态路径：from.value 直接是文件路径 + if (fromValue && fromValue !== '') { + return fromValue + } + + // 动态路径：__DIR__ . '/file.php' 等，parser 将其存在 _meta.dynamicFrom + const dynamicFrom = fromNode?._meta?.dynamicFrom + if (!dynamicFrom) return null + + // 获取当前文件路径用于解析 __DIR__ + let sourcefile: string | undefined + let current = node + const maxDepth = 50 + let depth = 0 + while (current && depth < maxDepth) { + sourcefile = current.sourcefile || current.loc?.sourcefile + if (sourcefile) break + current = current.parent + depth++ + } + + if (!sourcefile) return null + + // 递归求值动态路径表达式 + const evalPathExpr = (expr: any): string | null => { + if (!expr) return null + if (expr.type === 'Literal') { + return expr.value != null ? String(expr.value) : null + } + if (expr.type === 'Identifier' && expr.name === '__DIR__') { + return path.dirname(path.resolve(sourcefile!)) + } + // BinaryExpression：PHP 的 '.' 字符串拼接被 UAST 映射为 '+' + if (expr.type === 'BinaryExpression' && (expr.operator === '+' || expr.operator === '.')) { + const left = evalPathExpr(expr.left) + const right = evalPathExpr(expr.right) + if (left != null && right != null) return left + right + return null + } + // prettyPrint 兜底 + const printed = AstUtil.prettyPrint(expr) + return printed || null + } + + return evalPathExpr(dynamicFrom) + } + + /** + * PHP include/require 跨文件导入处理 + * PHP 的 include/require 语义 = 将文件内容粘贴到当前位置，所有顶层定义自动可用 + */ + processImportDirect(scope: any, node: any, state: any): any { + const resolvedPath = this.resolvePhpImportPath(node) + if (!resolvedPath) { + return new UndefinedValue() + } + + // 规范化为绝对路径 + let pathname = resolvedPath + if (!path.isAbsolute(pathname)) { + let sourcefile: string | undefined + let current = node + const maxDepth = 50 + let depth = 0 + while (current && depth < maxDepth) { + sourcefile = current.sourcefile || current.loc?.sourcefile + if (sourcefile) break + current = current.parent + depth++ + } + if (sourcefile) { + pathname = path.resolve(path.dirname(sourcefile.toString()), pathname) + } + } + + // 补全 .php 扩展名 + if (!pathname.endsWith('.php') && !fs.existsSync(pathname)) { + const withExt = pathname + '.php' + if (fs.existsSync(withExt)) { + pathname = withExt + } + } + + if (!fs.existsSync(pathname) || !fs.statSync(pathname).isFile()) { + return new UndefinedValue() + } + + pathname = path.resolve(pathname) + + // 检查模块缓存 + const cached = this.topScope.context.modules.members.get(pathname) + if (cached && typeof cached === 'object') { + this.registerImportedDefinitions(scope, cached) + return cached + } + + // 未缓存：解析并处理目标文件 + try { + const prog = FileUtil.loadAllFileText(pathname, ['php'])[0] + if (prog) { + this.sourceCodeCache.set(prog.file, prog.content.split(/\n/)) + const ast = Parser.parseSingleFile(prog.file, { ...this.options, sourcefile: prog.file }, this.sourceCodeCache) + if (ast) { + const moduleExports = this.processModule(ast, pathname) + if (moduleExports) { + this.registerImportedDefinitions(scope, moduleExports) + return moduleExports + } + } + } + } catch (e) { + handleException( + e, + `PhpAnalyzer.processImportDirect: 加载失败: ${pathname}`, + `Error in PhpAnalyzer.processImportDirect: failed to loading: ${pathname}` + ) + } + + return new UndefinedValue() + } + + /** + * 将被导入模块的顶层函数/类定义注册到当前 scope + * PHP 的 include 语义：所有顶层定义直接在全局可用 + */ + private registerImportedDefinitions(currentScope: any, moduleExports: any): void { + const targetModClos = moduleExports?.parent + if (!targetModClos?.value) return + + let registerTarget = currentScope + while (registerTarget && registerTarget.parent && registerTarget.parent !== this.topScope) { + registerTarget = registerTarget.parent + } + if (!registerTarget || registerTarget === this.topScope) { + registerTarget = currentScope + } + + // PHP include/require 语义：类(class)、函数(fclos)、变量(scoped/object) 均直接可用 + const importableVtypes = new Set(['scoped', 'object', 'class', 'fclos']) + + for (const key of Object.keys(targetModClos.value)) { + if (key === 'module' || key === 'exports') continue + const val = targetModClos.value[key] + if (!val) continue + if (importableVtypes.has(val.vtype)) { + registerTarget.value[key] = val + } + } + + if (targetModClos.members) { + const entries: Array<[string, any]> = targetModClos.members instanceof Map + ? Array.from(targetModClos.members.entries()) + : Object.entries(targetModClos.members) + for (const [key, val] of entries) { + if (!val || key === 'module' || key === 'exports') continue + if (importableVtypes.has((val as any)?.vtype)) { + if (registerTarget.members instanceof Map) { + registerTarget.members.set(key, val) + } else { + registerTarget.value[key] = val + } + } + } + } + } + + /** + * 从任意 scope 向上查找模块顶层 scope（parent 为 topScope 的 scope） + */ + private findModuleScope(scope: any): any { + let current = scope + while (current) { + if (current.parent === this.topScope) return current + current = current.parent + } + return null + } + + /** + * 从任意 scope 向上查找封闭的类定义 scope + * 类 scope 的标识：ast.cdef 存在（ClassDefinition 节点） + */ + private findEnclosingClassScope(scope: any): any { + let current = scope + while (current) { + if (current.ast?.cdef) return current + current = current.parent + } + // 兜底：检查 thisFClos 的 parent 链 + const thisFClos = this.thisFClos + if (thisFClos) { + let s = thisFClos + while (s) { + if (s.ast?.cdef) return s + s = s.parent + } + } + return null + } + + /** + * 从任意 scope 向上查找封闭的函数 scope + * 函数 scope 的标识：ast.fdef 存在（FunctionDefinition 节点） + */ + private findFunctionScope(scope: any): any { + let current = scope + while (current) { + if (current.ast?.fdef) return current + current = current.parent + } + return null + } + + // ─── global / static 变量声明处理 ─── + + /** + * 处理变量声明：拦截 global 和 static 存储修饰符 + * - global: 将变量绑定到模块顶层 scope + * - static: 从持久化 map 恢复跨调用保留的值 + */ + override processVariableDeclaration(scope: any, node: any, state: any): any { + const storage = node._meta?.storage + const varName = node.id?.type === 'Identifier' ? node.id.name : undefined + + // global $var：将模块顶层 scope 的同名变量绑定到当前函数 scope + if (storage === 'global' && varName) { + const modScope = this.findModuleScope(scope) + if (modScope) { + // 如果模块 scope 中已有值，绑定到当前 scope + const existing = modScope.value?.[varName] + if (existing !== undefined && existing !== null) { + scope.value[varName] = existing + } + // 标记该变量为 global，后续赋值时同步回模块 scope + if (!scope._globalVars) scope._globalVars = new Set() + scope._globalVars.add(varName) + } + return scope.value[varName] || new UndefinedValue() + } + + // static $var：从持久化 map 恢复之前的值 + if (storage === 'static' && varName) { + // 用函数 scope 的 qid 作为持久化 key + const funcKey = scope.qid || scope.sid || '' + let funcVars = this.staticVarMap.get(funcKey) + if (!funcVars) { + funcVars = new Map() + this.staticVarMap.set(funcKey, funcVars) + } + // 首次声明时执行基类逻辑初始化 + const initVal = super.processVariableDeclaration(scope, node, state) + // 如果持久化 map 中有之前保存的值，覆盖当前值 + const savedVal = funcVars.get(varName) + if (savedVal !== undefined) { + scope.value[varName] = savedVal + return savedVal + } + // 首次：将初始值存入持久化 map + funcVars.set(varName, initVal) + // 标记该变量为 static，后续赋值时同步到持久化 map + if (!scope._staticVars) scope._staticVars = new Map() + scope._staticVars.set(varName, funcKey) + return initVal + } + + return super.processVariableDeclaration(scope, node, state) + } + + /** + * 在 scope 链中查找变量值，不触发 processInstruction 避免副作用 + */ + private lookupVariableInScope(scope: any, name: string): any { + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[name] + if (val !== undefined && val !== null) return val + searchScope = searchScope.parent + } + return null + } + + /** + * PHP 变量函数解析：当 fclos 是字符串（函数名），在 scope 中查找对应的函数定义 + */ + private resolveVariableFunction(scope: any, fclosValue: string, state: any): any { + // 在当前 scope 及其父 scope 中查找函数名 + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[fclosValue] + if (val?.vtype === 'fclos' && val.ast?.fdef) { + return val + } + searchScope = searchScope.parent + } + // 在 topScope 中查找 + const topVal = this.topScope?.value?.[fclosValue] + if (topVal?.vtype === 'fclos' && topVal.ast?.fdef) { + return topVal + } + return null + } + + /** + * 静态分析函数体是否只返回常量值（字面量字符串/数字/布尔/null） + * @param isEnumMethod - 当方法属于 enum 时为 true，允许 $this->value 视为常量 + */ + private functionBodyReturnsOnlyConstants(fdef: any, isEnumMethod: boolean = false): boolean { + if (!fdef?.body) return false + const returnNodes: any[] = [] + this.collectReturnStatements(fdef.body, returnNodes) + if (returnNodes.length === 0) return false + return returnNodes.every((ret: any) => this.isConstantExpression(ret.argument, isEnumMethod)) + } + + /** 递归收集所有 ReturnStatement */ + private collectReturnStatements(node: any, results: any[]): void { + if (!node) return + if (Array.isArray(node)) { + for (const child of node) { + this.collectReturnStatements(child, results) + } + return + } + if (node.type === 'ReturnStatement') { + results.push(node) + return + } + // 不进入嵌套函数/类定义 + if (node.type === 'FunctionDefinition' || node.type === 'ClassDefinition') return + // 遍历 body 和常见子节点 + if (node.body) this.collectReturnStatements(node.body, results) + if (node.consequent) this.collectReturnStatements(node.consequent, results) + if (node.alternative) this.collectReturnStatements(node.alternative, results) + if (node.cases) { + for (const c of node.cases) { + this.collectReturnStatements(c.body, results) + } + } + } + + /** 判断表达式是否为常量（字面量或字面量拼接） */ + private isConstantExpression(expr: any, isEnumMethod: boolean = false): boolean { + if (!expr) return false + if (expr.type === 'Literal') return true + // 字符串拼接："safe_" . $this->value（PHP parser 将 . 转换为 UAST 的 +） + if (expr.type === 'BinaryExpression' && (expr.operator === '.' || expr.operator === '+')) { + return this.isConstantExpression(expr.left, isEnumMethod) && this.isConstantExpression(expr.right, isEnumMethod) + } + // enum 方法中的 $this->value 是 backing value，视为常量 + if (isEnumMethod && expr.type === 'MemberAccess' && (expr.object?.type === 'ThisExpression' || (expr.object?.type === 'Identifier' && expr.object.name === 'this'))) { + return true + } + return false + } + + /** + * 检查 MemberAccess 调用的对象是否为 enum 类型 + * PHP enum 在 UAST 中表示为 ClassDefinition，_meta.kind === 'enum' + */ + private isCalleeObjectEnum(scope: any, node: any, state: any): boolean { + if (node.callee?.type !== 'MemberAccess') return false + const objectVal = this.processInstruction(scope, node.callee.object, state) + if (!objectVal) return false + // 检查对象自身或父 scope 的 class 定义的 _meta.kind + if (objectVal.ast?.cdef?._meta?.kind === 'enum') return true + if (objectVal.parent?.ast?.cdef?._meta?.kind === 'enum') return true + if (objectVal.ast?.fdef?._meta?.kind === 'enum') return true + // 通过标识符查找类定义 + const objectName = node.callee.object?.name || node.callee.object?.object?.name + if (objectName) { + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[objectName] + if (val?.ast?.cdef?._meta?.kind === 'enum' || val?.ast?.fdef?._meta?.kind === 'enum') return true + searchScope = searchScope.parent + } + } + return false + } + + /** + * 无副作用地查找方法定义和 enum 标记 + * 不调用 processInstruction，只通过 scope 链静态查找 + */ + private findMethodDefStatic(scope: any, node: any): { fdef: any; isEnum: boolean } | null { + if (node.callee?.type !== 'MemberAccess') return null + const memberName = node.callee.member?.name || node.callee.member?.value || node.callee.property?.name || node.callee.property?.value + if (!memberName) return null + + // 从 callee.object 的 AST 名称查找对象变量 + const objectName = node.callee.object?.name || node.callee.object?.object?.name + if (!objectName) return null + + // 先在 scope 中查找对象变量值 + const objectVal = this.lookupVariableInScope(scope, objectName) + if (objectVal) { + // 在对象 scope 中查找方法 + const method = objectVal.value?.[memberName] + if (method?.ast?.fdef?.type === 'FunctionDefinition') { + const isEnum = objectVal.ast?.cdef?._meta?.kind === 'enum' || objectVal.ast?.fdef?._meta?.kind === 'enum' + return { fdef: method.ast.fdef, isEnum } + } + + // 在类定义 AST body 中查找方法 + const cdefBody = objectVal.ast?.cdef?.body || objectVal.ast?.fdef?.body + if (cdefBody) { + const isEnum = objectVal.ast?.cdef?._meta?.kind === 'enum' || objectVal.ast?.fdef?._meta?.kind === 'enum' + const body = Array.isArray(cdefBody) ? cdefBody : cdefBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return { fdef: member, isEnum } + } + } + } + } + + // 对象的父 scope（类成员/enum 值） + if (objectVal.parent?.ast?.cdef?.body) { + const isEnum = objectVal.parent.ast.cdef._meta?.kind === 'enum' + const body = Array.isArray(objectVal.parent.ast.cdef.body) ? objectVal.parent.ast.cdef.body : objectVal.parent.ast.cdef.body?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return { fdef: member, isEnum: !!isEnum } + } + } + } + } + } + + // 在 scope 链中查找类定义（按变量名查找） + const classDef = this.findClassDef(scope, objectName) + if (classDef) { + let isEnum = false + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[objectName] + if (val?.ast?.cdef?._meta?.kind === 'enum' || val?.ast?.fdef?._meta?.kind === 'enum') { + isEnum = true + break + } + searchScope = searchScope.parent + } + const body = Array.isArray(classDef) ? classDef : classDef?.body + if (body) { + const bodyArr = Array.isArray(body) ? body : body?.body + if (bodyArr) { + for (const member of bodyArr) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return { fdef: member, isEnum } + } + } + } + } + } + + // 兜底：在所有类/enum 定义中搜索同名方法 + // 用于变量名与类名不同的场景（如 $color = Color::Red; $color->label()） + const methodFromAll = this.findMethodInAllClassesWithEnum(scope, memberName) + if (methodFromAll) return methodFromAll + + return null + } + + /** + * 在 scope 链中查找函数定义的 AST（fdef），用于返回值常量分析 + */ + private findFunctionDef(scope: any, funcName: string): any { + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[funcName] + if (val?.ast?.fdef?.type === 'FunctionDefinition') { + return val.ast.fdef + } + searchScope = searchScope.parent + } + const topVal = this.topScope?.value?.[funcName] + if (topVal?.ast?.fdef?.type === 'FunctionDefinition') { + return topVal.ast.fdef + } + // 跨文件兜底：在所有模块 scope 中查找函数定义 + for (const [, modClos] of this.moduleScopes) { + const val = modClos.value?.[funcName] + if (val?.ast?.fdef?.type === 'FunctionDefinition') { + return val.ast.fdef + } + } + return null + } + + /** + * 从 MemberAccess 调用中查找方法的 fdef，支持对象方法、静态方法、enum 方法 + */ + private findMethodDef(scope: any, node: any, state: any): any { + if (node.callee?.type !== 'MemberAccess') return null + const memberName = node.callee.member?.name || node.callee.member?.value || node.callee.property?.name || node.callee.property?.value + if (!memberName) return null + + // 尝试解析对象以获取类定义 + const objectVal = this.processInstruction(scope, node.callee.object, state) + if (!objectVal) return null + + // 在对象 scope 中查找方法 + const method = objectVal.value?.[memberName] + if (method?.ast?.fdef?.type === 'FunctionDefinition') { + return method.ast.fdef + } + + // 在类定义 AST body 中查找方法 + const classBody = objectVal.ast?.cdef?.body || objectVal.ast?.fdef?.body + if (classBody) { + const body = Array.isArray(classBody) ? classBody : classBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return member + } + } + } + } + + // 对象是 enum 值或类成员，通过父 scope 查找类定义 + if (objectVal.parent?.ast?.cdef?.body) { + const body = Array.isArray(objectVal.parent.ast.cdef.body) ? objectVal.parent.ast.cdef.body : objectVal.parent.ast.cdef.body?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return member + } + } + } + } + + // 通过原始标识符名在 scope 中查找类定义（如 Color::Red → Color 是类） + const objectName = node.callee.object?.name || node.callee.object?.object?.name + if (objectName) { + const classDef = this.findClassDef(scope, objectName) + if (classDef) { + const body = Array.isArray(classDef) ? classDef : classDef?.body + if (body) { + const bodyArr = Array.isArray(body) ? body : body?.body + if (bodyArr) { + for (const member of bodyArr) { + if (member.type === 'FunctionDefinition' && member.id?.name === memberName) { + return member + } + } + } + } + } + } + + // 兜底：在所有 scope 中扫描全部类/enum 定义，查找匹配的方法 + const methodFromAll = this.findMethodInAllClasses(scope, memberName) + if (methodFromAll) return methodFromAll + + return null + } + + /** + * 在 scope 链的所有类/enum 定义中查找匹配的方法 fdef + * 用于 enum 值丢失类上下文后的兜底查找 + * 保守策略：当存在多个同名方法定义时，全部返回常量才认为安全 + */ + private findMethodInAllClasses(scope: any, methodName: string): any { + const allMatches: any[] = [] + let searchScope = scope + while (searchScope) { + if (searchScope.value) { + for (const key of Object.keys(searchScope.value)) { + const val = searchScope.value[key] + // 检查类定义的 cdef body + const cdefBody = val?.ast?.cdef?.body + if (cdefBody) { + const body = Array.isArray(cdefBody) ? cdefBody : cdefBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === methodName) { + allMatches.push(member) + } + } + } + } + } + } + searchScope = searchScope.parent + } + // 跨文件兜底：在所有模块 scope 中查找类定义的方法 + for (const [, modClos] of this.moduleScopes) { + if (modClos.value) { + for (const key of Object.keys(modClos.value)) { + const val = modClos.value[key] + const cdefBody = val?.ast?.cdef?.body + if (cdefBody) { + const body = Array.isArray(cdefBody) ? cdefBody : cdefBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === methodName) { + allMatches.push(member) + } + } + } + } + } + } + } + // 无匹配 + if (allMatches.length === 0) return null + // 仅有一个匹配，直接返回 + if (allMatches.length === 1) return allMatches[0] + // 多个匹配：只有全部返回常量时才安全（返回第一个供常量分析检查） + const allConstant = allMatches.every((m: any) => this.functionBodyReturnsOnlyConstants(m)) + return allConstant ? allMatches[0] : null + } + + /** + * 在所有类/enum 定义中查找方法，返回 { fdef, isEnum } + * 保守策略：仅在所有同名方法都返回常量时才返回结果 + */ + private findMethodInAllClassesWithEnum(scope: any, methodName: string): { fdef: any; isEnum: boolean } | null { + const allMatches: Array<{ fdef: any; isEnum: boolean }> = [] + let searchScope = scope + while (searchScope) { + if (searchScope.value) { + for (const key of Object.keys(searchScope.value)) { + const val = searchScope.value[key] + const cdefBody = val?.ast?.cdef?.body + if (cdefBody) { + const isEnum = val.ast.cdef._meta?.kind === 'enum' + const body = Array.isArray(cdefBody) ? cdefBody : cdefBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === methodName) { + allMatches.push({ fdef: member, isEnum: !!isEnum }) + } + } + } + } + } + } + searchScope = searchScope.parent + } + // 跨文件兜底：在所有模块 scope 中查找类/enum 定义的方法 + for (const [, modClos] of this.moduleScopes) { + if (modClos.value) { + for (const key of Object.keys(modClos.value)) { + const val = modClos.value[key] + const cdefBody = val?.ast?.cdef?.body + if (cdefBody) { + const isEnum = val.ast.cdef._meta?.kind === 'enum' + const body = Array.isArray(cdefBody) ? cdefBody : cdefBody?.body + if (body) { + for (const member of body) { + if (member.type === 'FunctionDefinition' && member.id?.name === methodName) { + allMatches.push({ fdef: member, isEnum: !!isEnum }) + } + } + } + } + } + } + } + if (allMatches.length === 0) return null + if (allMatches.length === 1) return allMatches[0] + // 多个匹配：仅当所有方法体都返回常量时才认为安全 + const allConstant = allMatches.every((m) => this.functionBodyReturnsOnlyConstants(m.fdef, m.isEnum)) + return allConstant ? allMatches[0] : null + } + + /** + * 在 scope 链中查找类的 AST body + */ + private findClassDef(scope: any, className: string): any { + let searchScope = scope + while (searchScope) { + const val = searchScope.value?.[className] + if (val?.ast?.cdef?.body) { + return val.ast.cdef.body + } + if (val?.ast?.fdef?.type === 'ClassDefinition' && val.ast.fdef.body) { + return val.ast.fdef.body + } + searchScope = searchScope.parent + } + const topVal = this.topScope?.value?.[className] + if (topVal?.ast?.cdef?.body) { + return topVal.ast.cdef.body + } + // 跨文件兜底：在所有模块 scope 中查找类定义 + for (const [, modClos] of this.moduleScopes) { + const val = modClos.value?.[className] + if (val?.ast?.cdef?.body) { + return val.ast.cdef.body + } + if (val?.ast?.fdef?.type === 'ClassDefinition' && val.ast.fdef.body) { + return val.ast.fdef.body + } + } + return null + } + + /** + * PHP 跨文件类名解析：new ClassName() 时先在当前 scope 查找，找不到则搜索 moduleScopes + * 模拟 PHP autoload 机制——项目内所有类定义在分析阶段全局可见 + */ + override processNewExpression(scope: any, node: any, state: any) { + const className = node.callee?.name + if (className && node.callee?.type === 'Identifier') { + const existing = this.processInstruction(scope, node.callee, state) + const isUnresolved = !existing || existing.vtype === 'undefine' || existing.vtype === 'symbol' + || existing.vtype === 'uninitialized' + if (isUnresolved) { + for (const [, modClos] of this.moduleScopes) { + const val = modClos.value?.[className] + if (val?.vtype === 'class' && val.ast?.cdef) { + // 将跨文件类定义注册到当前 scope，后续 base.processNewObject 可直接找到 + let registerScope = scope + while (registerScope.parent && registerScope.parent !== this.topScope) { + registerScope = registerScope.parent + } + registerScope.value[className] = val + break + } + } + } + } + return super.processNewExpression(scope, node, state) + } + + /** + * 处理调用表达式：增强基类逻辑，支持 PHP 变量函数、call_user_func、array_map、返回值常量分析 + * 核心原则：特殊 case 单独处理，其余调用委托给 super.processCallExpression 保持完整的污点传播 + */ + override processCallExpression(scope: any, node: any, state: any) { + try { + const calleeName = node.callee?.name + + // --- (string) 类型转换：调用 __toString 魔术方法 --- + // 基类已处理数值类型转换，这里只增强 string 转换 + if (node._meta?.isCast && calleeName === 'string' && node.arguments.length > 0) { + const objVal = this.processInstruction(scope, node.arguments[0], state) + if (objVal && objVal.value) { + const toStringMethod = objVal.value['__toString'] + if (toStringMethod?.vtype === 'fclos' && toStringMethod.ast?.fdef) { + const callInfo = { callArgs: this.buildCallArgs(node, [], toStringMethod) } + toStringMethod._this = objVal + return this.executeCall(node, toStringMethod, state, scope, callInfo) + } + } + return objVal + } + + // --- first-class callable 语法：func(...) 返回函数引用 --- + // AST 特征：CallExpression 参数列表仅包含一个 Noop 节点 + if (node.arguments.length === 1 && node.arguments[0]?.type === 'Noop' && calleeName) { + const fclos = this.resolveVariableFunction(scope, calleeName, state) + if (fclos) return fclos + } + + // --- call_user_func / call_user_func_array 特殊处理 --- + if (calleeName === 'call_user_func' || calleeName === 'call_user_func_array') { + if (node.arguments.length > 0) { + const firstArg = this.processInstruction(scope, node.arguments[0], state) + let targetFclos: any = null + if (firstArg?.vtype === 'primitive' && typeof firstArg.value === 'string') { + targetFclos = this.resolveVariableFunction(scope, firstArg.value, state) + } + if (firstArg?.vtype === 'fclos') { + targetFclos = firstArg + } + if (targetFclos) { + const restArgs = node.arguments.slice(1) + const argvalues: any[] = [] + for (const arg of restArgs) { + const argv = this.processInstruction(scope, arg, state) + if (Array.isArray(argv)) { + argvalues.push(...argv) + } else { + argvalues.push(argv) + } + } + const callInfo = { callArgs: this.buildCallArgs(node, argvalues, targetFclos) } + const res = this.executeCall(node, targetFclos, state, scope, callInfo) + if (res && this.checkerManager?.checkAtFunctionCallAfter) { + this.checkerManager.checkAtFunctionCallAfter(this, scope, node, state, { + callInfo, + fclos: targetFclos, + ret: res, + pcond: state.pcond, + einfo: state.einfo, + callstack: state.callstack, + }) + } + return res + } + } + } + + // --- array_map 特殊处理：调用回调并使用返回值 --- + if (calleeName === 'array_map' && node.arguments.length >= 2) { + const callbackArg = node.arguments[0] + const arrayArg = node.arguments[1] + const callbackVal = this.processInstruction(scope, callbackArg, state) + const arrayVal = this.processInstruction(scope, arrayArg, state) + + let resolvedCallback: any = null + if (callbackVal?.vtype === 'fclos' && callbackVal.ast?.fdef) { + resolvedCallback = callbackVal + } else if (callbackVal?.vtype === 'primitive' && typeof callbackVal.value === 'string') { + resolvedCallback = this.resolveVariableFunction(scope, callbackVal.value, state) + } + if (resolvedCallback) { + const dummyArgs = [arrayVal] + const callInfo = { callArgs: this.buildCallArgs(callbackArg, dummyArgs, resolvedCallback) } + const cbResult = this.executeCall(callbackArg, resolvedCallback, state, scope, callInfo) + const resultObj = new ObjectValue(scope.qid, { sid: '' }) + resultObj.value['0'] = cbResult + return resultObj + } + } + + // --- PHP 变量函数解析 --- + // 不调用 processInstruction，直接在 scope 中查找变量值，避免副作用 + if (node.callee?.type === 'Identifier' && calleeName) { + const varVal = this.lookupVariableInScope(scope, calleeName) + if (varVal?.vtype === 'primitive' && typeof varVal.value === 'string') { + const realFclos = this.resolveVariableFunction(scope, varVal.value, state) + if (realFclos?.ast?.fdef) { + // 触发基类的 checkAtFuncCallSyntax + if (this.checkerManager?.checkAtFuncCallSyntax) { + this.checkerManager.checkAtFuncCallSyntax(this, scope, node, state, { + pcond: state.pcond, + einfo: state.einfo, + }) + } + // 处理参数 + let argvalues: any[] = [] + let same_args = true + for (const arg of node.arguments) { + let argv = this.processInstruction(scope, arg, state) + if (arg.type === 'FunctionDefinition' && !realFclos.runtime?.execute) { + const funcDef = arg + if (funcDef.name?.includes('', 'constant', null, 'Literal', node.loc) + } + } + return res + } + } + } + + // --- __invoke 魔术方法：$obj() 调用调度到 __invoke --- + if (node.callee?.type === 'Identifier' && calleeName) { + const objVal = this.lookupVariableInScope(scope, calleeName) + if (objVal && objVal.vtype !== 'fclos' && objVal.vtype !== 'primitive' && objVal.value) { + const invokeMethod = objVal.value['__invoke'] + if (invokeMethod?.vtype === 'fclos' && invokeMethod.ast?.fdef) { + const argvalues: any[] = [] + for (const arg of node.arguments) { + argvalues.push(this.processInstruction(scope, arg, state)) + } + const callInfo = { callArgs: this.buildCallArgs(node, argvalues, invokeMethod) } + invokeMethod._this = objVal + return this.executeCall(node, invokeMethod, state, scope, callInfo) + } + } + } + + // --- array_push：将值添加到数组并修改原始引用 --- + if (calleeName === 'array_push' && node.arguments.length >= 2) { + const arrVal = this.processInstruction(scope, node.arguments[0], state) + for (let i = 1; i < node.arguments.length; i++) { + const elemVal = this.processInstruction(scope, node.arguments[i], state) + if (arrVal && arrVal.vtype === 'object' && arrVal.value) { + // 找到下一个数字索引 + let nextIdx = 0 + for (const k of Object.keys(arrVal.value)) { + const n = parseInt(k, 10) + if (!isNaN(n) && n >= nextIdx) nextIdx = n + 1 + } + arrVal.value[String(nextIdx)] = elemVal + // 传播污点 + if (elemVal?.taint?.isTaintedRec && arrVal.taint) { + arrVal.taint.propagateFrom(elemVal) + } + } + } + return arrVal + } + + // --- array_pop：从数组末尾取出值 --- + if (calleeName === 'array_pop' && node.arguments.length >= 1) { + const arrVal = this.processInstruction(scope, node.arguments[0], state) + if (arrVal && arrVal.vtype === 'object' && arrVal.value) { + // 找到最大数字索引的值 + let maxIdx = -1 + for (const k of Object.keys(arrVal.value)) { + const n = parseInt(k, 10) + if (!isNaN(n) && n > maxIdx) maxIdx = n + } + if (maxIdx >= 0) { + const popped = arrVal.value[String(maxIdx)] + delete arrVal.value[String(maxIdx)] + if (popped) return popped + } + // 兜底：返回数组本身的污点状态 + return arrVal + } + } + + // --- static::method() 后期静态绑定：将 static 解析为实际调用类 --- + if (node.callee?.type === 'MemberAccess' && node.callee.object?.name === 'static' + && node.callee._meta?.isStatic) { + const methodName = node.callee.property?.name + if (methodName) { + // thisFClos 在静态方法继承调用时指向实际调用类（如 TaintedProvider::process() 中 thisFClos = TaintedProvider） + const lateStaticClass = this.thisFClos?.ast?.cdef ? this.thisFClos : this.findEnclosingClassScope(scope) + if (lateStaticClass) { + const method = lateStaticClass.value?.[methodName] + if (method?.vtype === 'fclos' && method.ast?.fdef) { + const argvalues: any[] = [] + for (const arg of node.arguments) { + argvalues.push(this.processInstruction(scope, arg, state)) + } + const callInfo = { callArgs: this.buildCallArgs(node, argvalues, method) } + return this.executeCall(node, method, state, scope, callInfo) + } + } + } + } + + // --- 非特殊调用：委托给基类 --- + // 包含完整的 checkAtFuncCallSyntax、参数处理、executeCall、checkAtFunctionCallAfter + + // 引用传参绑定：建立 by-ref 参数到调用方变量的映射 + const savedByRefBindings = this._byRefBindings + this._byRefBindings = [] + if (node.callee?.type === 'Identifier' && calleeName && node.arguments?.length > 0) { + const fdef = this.findFunctionDef(scope, calleeName) + if (fdef?.parameters) { + for (let i = 0; i < fdef.parameters.length && i < node.arguments.length; i++) { + const param = fdef.parameters[i] + if (param._meta?.byref && node.arguments[i]?.type === 'Identifier') { + this._byRefBindings.push({ + paramName: param.id?.name || param.name, + callerArgNode: node.arguments[i], + callerScope: scope, + }) + } + } + } + } + + const res = super.processCallExpression(scope, node, state) + this._byRefBindings = savedByRefBindings + + // --- 返回值常量分析（post-check）--- + // 如果调用结果被污染，但函数体只返回字面量常量，则切断污点 + if (res?.taint?.isTaintedRec) { + if (node.callee?.type === 'MemberAccess') { + // 方法调用：通过 scope 静态查找方法定义，无 processInstruction 副作用 + const methodInfo = this.findMethodDefStatic(scope, node) + if (methodInfo?.fdef && this.functionBodyReturnsOnlyConstants(methodInfo.fdef, methodInfo.isEnum)) { + return new PrimitiveValue(scope.qid, '', 'constant', null, 'Literal', node.loc) + } + // __call 魔术方法回退：方法未找到时，检查对象的 __call 方法 + if (!methodInfo) { + const objVal = this.lookupVariableInScope(scope, node.callee.object?.name || '') + const callMethod = objVal?.value?.['__call'] + if (callMethod?.ast?.fdef && this.functionBodyReturnsOnlyConstants(callMethod.ast.fdef)) { + return new PrimitiveValue(scope.qid, '', 'constant', null, 'Literal', node.loc) + } + } + } else if (node.callee?.type === 'Identifier' && calleeName) { + // 普通函数调用：在 scope 中查找函数定义 + const fdef = this.findFunctionDef(scope, calleeName) + if (fdef && this.functionBodyReturnsOnlyConstants(fdef)) { + return new PrimitiveValue(scope.qid, '', 'constant', null, 'Literal', node.loc) + } + } + } + + return res + } catch (e) { + return new UndefinedValue() + } + } + + // ─── PHP 魔术方法支持 + $_SERVER 白名单 ─── + + /** $_SERVER 安全字段：值由服务器控制，不可被用户注入 */ + private static readonly SERVER_SAFE_FIELDS = new Set([ + 'REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT', 'SERVER_PROTOCOL', + 'SERVER_SOFTWARE', 'SERVER_ADDR', 'DOCUMENT_ROOT', 'SCRIPT_FILENAME', + 'SCRIPT_NAME', 'PHP_SELF', 'GATEWAY_INTERFACE', 'REQUEST_TIME', + 'REQUEST_TIME_FLOAT', 'HTTPS', 'REMOTE_PORT', 'SERVER_ADMIN', + ]) + + /** + * 属性读取：$_SERVER 安全字段白名单 + __get 魔术方法 + */ + override processMemberAccess(scope: any, node: any, state: any): any { + // $_SERVER 安全字段白名单 + const objectName = node.object?.name + if (objectName === '_SERVER' && node.computed) { + const fieldName = node.property?.value || node.property?.name + if (fieldName && PhpAnalyzer.SERVER_SAFE_FIELDS.has(fieldName)) { + return new PrimitiveValue(scope.qid, `<$_SERVER_${fieldName}>`, fieldName, null, 'Literal', node.loc) + } + } + + // $GLOBALS['key'] 读取：从全局共享存储获取值 + if (objectName === 'GLOBALS' && node.computed) { + const key = node.property?.value ?? node.property?.name + if (key !== undefined && key !== null) { + const val = this.globalsMap.get(String(key)) + if (val !== undefined && val !== null) return val + // 兜底：从模块顶层 scope 查找 + const modScope = this.findModuleScope(scope) + if (modScope) { + const modVal = modScope.value?.[String(key)] + if (modVal !== undefined && modVal !== null) return modVal + } + } + } + + // self::$prop 读取：从类定义 scope 获取静态属性值 + if (objectName === 'self' && node._meta?.isStatic) { + const propName = node.property?.name || node.property?.value + if (propName) { + const classScope = this.findEnclosingClassScope(scope) + if (classScope) { + const val = classScope.value?.[propName] + if (val !== undefined && val !== null) return val + } + } + } + + const defscope = this.processInstruction(scope, node.object, state) + const prop = node.property + let resolved_prop = prop + if (node.computed) { + resolved_prop = this.processInstruction(scope, prop, state) + } else { + if (prop.type !== 'Identifier' && prop.type !== 'Literal') { + resolved_prop = this.processInstruction(scope, prop, state) + } + } + const res = this.getMemberValue(defscope, resolved_prop, state) + + // 数组索引精度：如果计算属性访问得到了从父对象传播的污点， + // 检查原始索引值是否为未污染的原始值（如字面量 "safe"） + if (node.computed && res?.taint?.isTaintedRec && defscope?.vtype === 'object') { + const indexKey = resolved_prop?.value ?? resolved_prop?.name + if (indexKey !== undefined && indexKey !== null) { + const rawVal = defscope._members?.get(String(indexKey)) + if (rawVal && rawVal.vtype === 'primitive' && !rawVal.taint?.isTaintedRec) { + return rawVal + } + } + } + + // __get 魔术方法：属性不存在时调用 + if (defscope?.value && (res.vtype === 'undefine' || res.vtype === 'uninitialized' || res.vtype === 'symbol')) { + const getMethod = defscope.value['__get'] + if (getMethod?.vtype === 'fclos' && getMethod.ast?.fdef) { + const propName = resolved_prop?.name || resolved_prop?.value || '' + const propArg = new PrimitiveValue(scope.qid, propName, propName, null, 'Literal', node.loc) + const callInfo = { callArgs: this.buildCallArgs(node, [propArg], getMethod) } + getMethod._this = defscope + const magicResult = this.executeCall(node, getMethod, state, scope, callInfo) + if (magicResult) { + if (node.object.type !== 'SuperExpression') { + magicResult._this = defscope + } + return magicResult + } + } + } + + if (node.object.type !== 'SuperExpression' && (res.vtype !== 'union' || !Array.isArray(res.value))) { + res._this = defscope + } + if (this.checkerManager && this.checkerManager.checkAtMemberAccess) { + this.checkerManager.checkAtMemberAccess(this, defscope, node, state, { res }) + } + return res + } + + /** + * 赋值：global/static 同步 + $GLOBALS 写入 + self:: 静态属性 + TupleExpression 解构 + __set 魔术方法 + */ + override processAssignmentExpression(scope: any, node: any, state: any): any { + // --- 引用赋值 $b = &$a：建立别名关系 --- + if (node.operator === '=' && node._meta?.byref + && node.left?.type === 'Identifier' && node.right?.type === 'Identifier') { + const leftName = node.left.name + const rightName = node.right.name + // 在函数作用域上记录双向别名 + const funcScope = this.findFunctionScope(scope) + if (funcScope) { + if (!funcScope._refAliases) funcScope._refAliases = new Map>() + if (!funcScope._refAliases.has(leftName)) funcScope._refAliases.set(leftName, new Set()) + if (!funcScope._refAliases.has(rightName)) funcScope._refAliases.set(rightName, new Set()) + funcScope._refAliases.get(leftName)!.add(rightName) + funcScope._refAliases.get(rightName)!.add(leftName) + } + } + + // --- $GLOBALS['key'] = expr：写入全局共享存储 + 模块顶层 scope --- + if (node.left?.type === 'MemberAccess' && node.left.object?.name === 'GLOBALS' && node.left.computed) { + const keyNode = node.left.property + const key = keyNode?.value ?? keyNode?.name + if (key !== undefined && key !== null) { + const rhs = this.processInstruction(scope, node.right, state) + this.globalsMap.set(String(key), rhs) + const modScope = this.findModuleScope(scope) + if (modScope) { + modScope.value[String(key)] = rhs + } + return rhs + } + } + + // --- self::$prop = expr：写入类定义 scope 的静态属性 --- + if (node.left?.type === 'MemberAccess' && node.left.object?.name === 'self' && node.left._meta?.isStatic) { + const propName = node.left.property?.name || node.left.property?.value + if (propName) { + const rhs = this.processInstruction(scope, node.right, state) + // 查找封闭类的 scope（thisFClos 在类方法执行时指向类 scope） + const classScope = this.findEnclosingClassScope(scope) + if (classScope) { + classScope.value[propName] = rhs + } + return rhs + } + } + + // 检查是否是对象属性赋值：$obj->prop = $value + if (node.left?.type === 'MemberAccess') { + const defscope = this.processInstruction(scope, node.left.object, state) + if (defscope?.value) { + const setMethod = defscope.value['__set'] + if (setMethod?.vtype === 'fclos' && setMethod.ast?.fdef) { + const rhs = this.processInstruction(scope, node.right, state) + const propName = node.left.property?.name || node.left.property?.value || '' + const propArg = new PrimitiveValue(scope.qid, propName, propName, null, 'Literal', node.loc) + const callInfo = { callArgs: this.buildCallArgs(node, [propArg, rhs], setMethod) } + setMethod._this = defscope + this.executeCall(node, setMethod, state, scope, callInfo) + return rhs + } + } + } + + // TupleExpression 解构：从 ObjectValue 中按数字索引提取元素，避免整体污点扩散 + if (node.operator === '=' && node.left?.type === 'TupleExpression') { + const tmpVal = this.processInstruction(scope, node.right, state) + const oldVal = this.processInstruction(scope, node.left, state) + const hasNumericKeys = tmpVal && tmpVal.vtype === 'object' && tmpVal.value + for (let k = 0; k < node.left.elements.length; k++) { + const x = node.left.elements[k] + if (!x) continue + const xName = x.type === 'Identifier' ? x.name : undefined + if (xName === '_') continue + + let val: any + if (tmpVal && tmpVal.type === 'TupleExpression') { + val = tmpVal.elements[k] + } else if (hasNumericKeys) { + // 从 ObjectValue 中按数字索引提取，实现 field-sensitive 解构 + const indexed = tmpVal.value[String(k)] + val = indexed || tmpVal + // 嵌套 TupleExpression（如 [[$a,$b], $rest] = $arr）：递归处理 + if (x.type === 'TupleExpression' && indexed && indexed.vtype === 'object') { + for (let j = 0; j < x.elements.length; j++) { + const innerElem = x.elements[j] + if (!innerElem) continue + const innerName = innerElem.type === 'Identifier' ? innerElem.name : undefined + if (innerName === '_') continue + const innerVal = indexed.value[String(j)] || indexed + this.saveVarInScope(scope, innerElem, innerVal, state, null) + if (this.checkerManager?.checkAtAssignment) { + const lscope = this.getDefScope(scope, innerElem) + this.checkerManager.checkAtAssignment(this, scope, node, state, { + lscope, + lvalue: oldVal, + rvalue: innerVal, + pcond: state.pcond, + binfo: state.binfo, + entry_fclos: this.entry_fclos, + einfo: state.einfo, + state, + }) + } + } + continue + } + } else { + val = tmpVal + } + const oldV = oldVal && oldVal.type === 'TupleExpression' ? oldVal.elements[k] : oldVal + this.saveVarInScope(scope, x, val, state, oldV) + if (this.checkerManager?.checkAtAssignment) { + const lscope = this.getDefScope(scope, x) + this.checkerManager.checkAtAssignment(this, scope, node, state, { + lscope, + lvalue: oldVal, + rvalue: val, + pcond: state.pcond, + binfo: state.binfo, + entry_fclos: this.entry_fclos, + einfo: state.einfo, + state, + }) + } + } + return tmpVal + } + + const result = super.processAssignmentExpression(scope, node, state) + + // --- 引用别名传播：写入变量时同步到所有别名 --- + if (node.operator === '=' && node.left?.type === 'Identifier') { + const varName = node.left.name + const funcScope = this.findFunctionScope(scope) + const aliases = funcScope?._refAliases?.get(varName) as Set | undefined + if (aliases && aliases.size > 0) { + const val = this.lookupVariableInScope(scope, varName) + if (val) { + for (const alias of aliases) { + this.saveVarInScope(scope, { type: 'Identifier', name: alias }, val, state) + } + } + } + // 引用传参回写：函数内写入 by-ref 参数时同步到调用方变量 + if (this._byRefBindings?.length > 0) { + const binding = this._byRefBindings.find((b: any) => b.paramName === varName) + if (binding) { + const val = this.lookupVariableInScope(scope, varName) + if (val) { + this.saveVarInScope(binding.callerScope, binding.callerArgNode, val, state) + } + } + } + } + + // --- global 变量赋值后同步到模块顶层 scope --- + if (node.left?.type === 'Identifier' && node.left.name) { + const varName = node.left.name + // 在 scope 链中查找是否有 _globalVars 标记 + let searchScope = scope + while (searchScope) { + if (searchScope._globalVars?.has(varName)) { + const modScope = this.findModuleScope(searchScope) + if (modScope) { + const val = this.lookupVariableInScope(scope, varName) + if (val) modScope.value[varName] = val + } + break + } + searchScope = searchScope.parent + } + // --- static 变量赋值后同步到持久化 map --- + searchScope = scope + while (searchScope) { + if (searchScope._staticVars?.has(varName)) { + const funcKey = searchScope._staticVars.get(varName) + if (funcKey) { + const funcVars = this.staticVarMap.get(funcKey) + const val = this.lookupVariableInScope(scope, varName) + if (funcVars && val) funcVars.set(varName, val) + } + break + } + searchScope = searchScope.parent + } + } + + return result + } + + /** + * 数组字面量：PHP parser 将 SpreadElement 包装在 ObjectProperty 中， + * 需要跳过对 spread 结果的覆写赋值，保持按索引展开的精度 + */ + override processObjectExpression(scope: any, node: any, state: any): any { + const objSid = `` + let res = new Scoped(scope.qid, { + sid: objSid, + parent: scope, + ast: node, + _skipRegister: true, + }) + if (node.properties) { + for (const property of node.properties) { + let name: any + let fvalue: any + const propertyType = property.type + switch (propertyType) { + case 'ObjectMethod': { + name = property.key?.name + fvalue = this.createFuncScope(property, scope) + fvalue.ast.fdef = _.clone(fvalue.ast.fdef) + if (fvalue.ast.fdef) fvalue.ast.fdef.type = 'FunctionDefinition' + if (fvalue.ast?.node) fvalue.ast.node.type = 'FunctionDefinition' + break + } + case 'SpreadElement': { + this.processInstruction(res, property, state) + continue + } + case 'ObjectProperty': + default: { + if (property.type !== 'ObjectProperty') continue + let { key } = property + switch (key.type) { + case 'Literal': + name = key.value + break + case 'Identifier': + name = key.name + break + default: + key = this.processInstruction(res, key, state) + name = key.type === 'Literal' ? key.value : key.type === 'Identifier' ? key.name : undefined + break + } + // PHP 中 SpreadElement 被包装在 ObjectProperty.value 中 + // 直接展开数组元素到结果对象中，保持按索引的精度 + if (property.value?.type === 'SpreadElement') { + const spreadVal = this.processInstruction(scope, property.value.argument, state) + if (spreadVal && spreadVal.vtype === 'object' && spreadVal.value) { + // 获取当前结果中已有的最大数字索引 + let nextIdx = 0 + for (const existingKey of Object.keys(typeof res.value === 'object' ? res.value : {})) { + const n = parseInt(existingKey, 10) + if (!isNaN(n) && n >= nextIdx) nextIdx = n + 1 + } + // 从源数组中按数字索引提取元素并追加到结果 + const srcKeys = Object.keys(typeof spreadVal.value === 'object' ? spreadVal.value : {}) + .filter((k: string) => /^\d+$/.test(k)) + .sort((a: string, b: string) => parseInt(a) - parseInt(b)) + for (const srcKey of srcKeys) { + const elemVal = spreadVal.value[srcKey] + if (elemVal && elemVal.vtype !== 'undefine') { + res.value[String(nextIdx)] = elemVal + if (elemVal.taint?.isTaintedRec) res.taint?.propagateFrom(elemVal) + nextIdx++ + } + } + } + continue + } + fvalue = this.processInstruction(res, property.value, state) + if (fvalue?.taint?.isTaintedRec) res.taint?.propagateFrom(fvalue) + if (property.value?.type === 'FunctionDefinition') fvalue.parent = res + break + } + } + res.value[name] = fvalue + } + res.length = node.properties.length + } + res = new ObjectValue(scope.qid, { ...res, sid: objSid }) + res.vtype = 'object' + res._this = res + return res + } + + // ─── PHP 控制流信号：break + throw + continue ─── + + /** 三信号属性 */ + _breakSignal = false + _throwSignal = false + _continueSignal = false + + override processBreakStatement(scope: any, node: any, state: any): any { + this._breakSignal = true + return new UndefinedValue() + } + + override processContinueStatement(scope: any, node: any, state: any): any { + this._continueSignal = true + return new UndefinedValue() + } + + override processThrowStatement(scope: any, node: any, state: any): any { + const result = super.processThrowStatement(scope, node, state) + this._throwSignal = true + return result + } + + /** 块语句：信号后跳过剩余语句 */ + override processScopedStatement(scope: any, node: any, state: any): any { + const { loc } = node + let scopeName + if (loc) { + if (!scope.qid) { + const prefix = loc.sourcefile?.substring(Config.maindirPrefix.length) + const lastDotIndex = prefix?.lastIndexOf('.') ?? -1 + const relateFileName = lastDotIndex >= 0 ? prefix?.substring(0, lastDotIndex) : prefix + scopeName = `${relateFileName}` + } else { + scopeName = `` + } + } else { + scopeName = `` + } + const block_scope = Scope.createSubScope(scopeName, scope, 'scope') + node.body + .filter((n: any) => needCompileFirst(n.type)) + .forEach((s: any) => this.processInstruction(block_scope, s, state)) + node.body + .filter((n: any) => !needCompileFirst(n.type)) + .forEach((s: any) => { + if (this._breakSignal || this._throwSignal || this._continueSignal) return + this.processInstruction(block_scope, s, state) + }) + + if (this.checkerManager && this.checkerManager.checkAtEndOfBlock) { + this.checkerManager.checkAtEndOfBlock(this, scope, node, state, {}) + } + return new VoidValue() + } + + /** switch 语句：break 消费，throw 退出 */ + override processSwitchStatement(scope: any, node: any, state: any): any { + const test = this.processInstruction(scope, node.discriminant, state) + if (test && test.type === 'Literal') { + const testValue = test.value + for (const caseClause of node.cases) { + if ( + !caseClause.test || + (caseClause.test.type === 'Literal' && caseClause.test.value === testValue) + ) { + const result = this.processInstruction(scope, caseClause.body, state) + this._breakSignal = false + return result + } + } + return new UndefinedValue() + } + + const scopes: any[] = [] + const n = node.cases.length + const substates = MemState.forkStates(state, n) + let i = 0 + for (const caseClause of node.cases) { + const scope1 = MemState.cloneScope(scope, state) + scopes.push(scope1) + const st = substates[i++] || substates[0] + this.processInstruction(scope1, caseClause.body, st) + this._breakSignal = false + if (this._throwSignal) break + } + MemState.unionValues(scopes, substates, state.brs) + return new UndefinedValue() + } + + /** for 语句：三信号处理 */ + override processForStatement(scope: any, node: any, state: any): any { + StateUtil.pushLoopInfo(state, node) + if (node.init) { + this.processInstruction(scope, node.init, state) + } + + let test = node.test ? this.processInstruction(scope, node.test, state) : null + if (test && test.type === 'Literal') { + if (test.value) this.processInstruction(scope, node.body, state) + } else { + this.processInstruction(scope, node.body, state) + } + this._continueSignal = false + if (this._breakSignal) { + this._breakSignal = false + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + if (this._throwSignal) { + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + if (node.update) { + this.processInstruction(scope, node.update, state) + } + test = this.processInstruction(scope, node.test, state) + if (test && test.type === 'Literal') { + if (test.value) this.processInstruction(scope, node.body, state) + } else this.processInstruction(scope, node.body, state) + this._continueSignal = false + if (this._breakSignal) { + this._breakSignal = false + } + + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + + /** while 语句：三信号处理 */ + override processWhileStatement(scope: any, node: any, state: any): any { + StateUtil.pushLoopInfo(state, node) + let test = this.processInstruction(scope, node.test, state) + if (test && test.type === 'Literal') { + if (test.value) this.processInstruction(scope, node.body, state) + } else this.processInstruction(scope, node.body, state) + this._continueSignal = false + if (this._breakSignal) { + this._breakSignal = false + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + if (this._throwSignal) { + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + + test = this.processInstruction(scope, node.test, state) + if (test && test.type === 'Literal') { + if (test.value) this.processInstruction(scope, node.body, state) + } else this.processInstruction(scope, node.body, state) + this._continueSignal = false + if (this._breakSignal) { + this._breakSignal = false + } + + StateUtil.popLoopInfo(state) + return new UndefinedValue() + } + + /** range/foreach 语句：三信号处理 */ + override processRangeStatement(scope: any, node: any, state: any): any { + const { key, value, right, body } = node + scope = Scope.createSubScope( + ``, + scope + ) + const rightVal = this.processInstruction(scope, right, state) + if ( + !Array.isArray(rightVal) && + (this.inRange || + rightVal?.vtype === 'primitive' || + Object.keys(rightVal.getRawValue()).filter((k: string) => !k.startsWith('__yasa')).length === 0 || + rightVal?.vtype === 'union') + ) { + if (value) { + if (value.type === 'VariableDeclaration') { + this.saveVarInCurrentScope(scope, value.id, rightVal, state) + } else if (value.type === 'TupleExpression') { + for (const ele of value.elements) { + this.saveVarInCurrentScope(scope, ele.name, rightVal, state) + } + } else { + this.saveVarInScope(scope, value, rightVal, state) + } + } + if (key) { + this.saveVarInScope(scope, key, rightVal, state) + } + this.processInstruction(scope, body, state) + } else { + this.inRange = true + if (this.isNullLiteral(rightVal)) { + this.inRange = false + return undefined as any + } + const itr = this.getValueIterator(rightVal, filterDataFromScope) + let countLimit = 30 + for (let { value: field, done } = itr.next(); !done; { value: field, done } = itr.next()) { + if (countLimit-- === 0) { + break + } + if (!field) continue + let { k, v } = field + if (key) { + if (key.type === 'VariableDeclaration') { + this.saveVarInCurrentScope(scope, key.id, k, state) + } else { + if (typeof k === 'string') k = new PrimitiveValue(scope.qid, k, k, null, key.type, key.loc, key) + this.saveVarInScope(scope, key, k, state) + } + } + if (value) { + if (value.type === 'VariableDeclaration') { + this.saveVarInCurrentScope(scope, value.id, v, state) + } else if (value.type === 'TupleExpression') { + for (let i = 0; i < value.elements.length; i++) { + const eleVal = v?.members?.get(String(i)) ?? v + this.saveVarInCurrentScope(scope, value.elements[i].name, eleVal, state) + } + } else { + this.saveVarInScope(scope, value, v, state) + } + } + this.processInstruction(scope, body, state) + this._continueSignal = false + if (this._breakSignal) { + this._breakSignal = false + break + } + if (this._throwSignal) break + } + this.inRange = false + } + return new VoidValue() + } + + /** 序列表达式：信号后跳过剩余 */ + override processSequence(scope: any, node: any, state: any) { + let val + for (const i in node.expressions) { + if (this._breakSignal || this._throwSignal || this._continueSignal) break + const expr = node.expressions[i] + val = this.processInstruction(scope, expr, state) + } + return val + } + + /** try 语句：消费 throw 信号 */ + override processTryStatement(scope: any, node: any, state: any): any { + state.throwstack = state.throwstack ?? [] + this.processInstruction(scope, node.body, state) + this._throwSignal = false + const { handlers } = node + if (handlers) { + for (const clause of handlers) { + if (!clause.parameter) { + this.processInstruction(scope, clause.body, state) + continue + } + // PHP catch 参数绑定：从 throwstack 取出抛出值赋给 catch 变量 + for (const param of clause.parameter) { + if (param?.type === 'VariableDeclaration' && param._meta?.catchTypes && state.throwstack?.length > 0) { + const thrownVal = state.throwstack.shift() + const varName = param.id?.name + if (varName && thrownVal) { + this.saveVarInCurrentScope(scope, param.id, thrownVal, state) + continue + } + } + this.processInstruction(scope, param, state) + } + this.processInstruction(scope, clause.body, state) + } + // catch handler 内的 re-throw 不传播到 try 外部 + this._throwSignal = false + } + if (node.finalizer) this.processInstruction(scope, node.finalizer, state) + return new UndefinedValue() + } + + /** if 语句：信号隔离——break/throw 传播，continue 不传播（单分支） */ + override processIfStatement(scope: any, node: any, state: any): any { + const test = this.processInstruction(scope, node.test, state) + if (!node.consequent || node.consequent.type === 'Noop') return new VoidValue() + + switch (test?.type) { + case 'Literal': { + if (test.value) { + return this.processInstruction(scope, node.consequent, state) + } else if (node.alternative && node.alternative.type !== 'Noop') { + return this.processInstruction(scope, node.alternative, state) + } + return new VoidValue() + } + default: { + if (node.alternative && node.alternative.type !== 'Noop') { + const rscope = MemState.cloneScope(scope, state) + const substates = MemState.forkStates(state) + const lstate = substates[0] + const rstate = substates[1] + this.processLRScopeInternal(lstate, rstate, state, test) + + // 保存信号，分别处理两个分支 + const savedBreak = this._breakSignal + const savedThrow = this._throwSignal + const savedContinue = this._continueSignal + this._breakSignal = false + this._throwSignal = false + this._continueSignal = false + this.processInstruction(scope, node.consequent, lstate) + const leftBreak = this._breakSignal + const leftThrow = this._throwSignal + const leftContinue = this._continueSignal + this._breakSignal = false + this._throwSignal = false + this._continueSignal = false + this.processInstruction(rscope, node.alternative, rstate) + const rightBreak = this._breakSignal + const rightThrow = this._throwSignal + const rightContinue = this._continueSignal + // 两个分支都设置了信号才传播 + this._breakSignal = savedBreak || (leftBreak && rightBreak) + this._throwSignal = savedThrow || (leftThrow && rightThrow) + this._continueSignal = savedContinue || (leftContinue && rightContinue) + + MemState.unionValues([scope, rscope], substates, state.brs) + this.postBranchProcessing(node, test, state, lstate, rstate) + } else { + // 单分支：break/throw 传播，continue 不传播 + const substates = MemState.forkStates(state, 1) + const lstate = substates[0] + const { pcond } = state + lstate.pcond = pcond.slice(0) + lstate.parent = state + if (test) lstate.pcond.push(test) + lstate.binfo = _.clone(state.binfo) + + const savedBreak = this._breakSignal + const savedThrow = this._throwSignal + const savedContinue = this._continueSignal + this._breakSignal = false + this._throwSignal = false + this._continueSignal = false + this.processInstruction(scope, node.consequent, lstate) + this._breakSignal = savedBreak || this._breakSignal + this._throwSignal = savedThrow || this._throwSignal + this._continueSignal = savedContinue + + MemState.unionValues([scope, scope], substates, lstate.brs) + this.postBranchProcessing(node, test, state, lstate) + } + } + } + return new VoidValue() + } + + /** 函数调用边界：保存/恢复信号，防止泄漏到调用方 */ + override executeFdeclOrExecute(fclos: any, state: any, node: any, scope: any, fdecl: any, fname: any, execute_builtin: any, callInfo: any): any { + const savedThrow = this._throwSignal + const savedBreak = this._breakSignal + const savedContinue = this._continueSignal + this._throwSignal = false + this._breakSignal = false + this._continueSignal = false + const result = super.executeFdeclOrExecute(fclos, state, node, scope, fdecl, fname, execute_builtin, callInfo) + this._throwSignal = savedThrow + this._breakSignal = savedBreak + this._continueSignal = savedContinue + return result + } +} + +/** 判断 AST 节点是否需要优先编译（函数/类定义 hoisting） */ +function needCompileFirst(type: any) { + return ['FunctionDefinition', 'ClassDefinition'].indexOf(type) !== -1 +} + +export = PhpAnalyzer diff --git a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts b/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts new file mode 100644 index 00000000..d682c15d --- /dev/null +++ b/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts @@ -0,0 +1,161 @@ +/** + * Haodf DataBucket entrypoint 采集器 + * + * 适用项目：mobileapi / weixmpapi / wap + * + * 背景： + * - mobileapi 的 Controller 层（`MobileApiApp::run` + `BaseController`）通过 `__call` 魔术方法把请求 + * 转发到具体 DataBucket，真正的业务入口是 `controllers//<*>databucket.php` 里的 public 方法。 + * - DataBucket 方法签名不固定（按 RPC 参数逐个展开，如 `($userId, $os, $v)`），不能按 Controller 的 "==2" 判定。 + * - 历史拼写/命名漂移：实际文件后缀存在 `databucket.php / databacket.php / databuck.php / bucket.php` 四种。 + * + * 识别策略： + * 1. 类名以 `DataBucket / DataBacket / DataBuck / Bucket` 之一结尾（大小写不敏感），或继承链包含 + * `BaseDataBucket`/`DataBucket` 等基类。 + * 2. 方法：public 非魔术，参数数 >= 1（所有参数都当外部输入）。 + * 3. 排除 PHP 魔术方法 / setInstance / getInstance / DI 模板。 + * + * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='HaodfDataBucket'。 + * taint 层把所有参数都当 source（走 SOA 同样的全参污点分支）。 + */ +const { extractRelativePath } = require('../../../../../util/file-util') +const EntryPoint = require('../../../common/entrypoint') +const Constant = require('../../../../../util/constant') +const logger = require('../../../../../util/logger')(__filename) +const { + buildClassInheritanceMap, + EXCLUDED_METHODS, +} = require('../../sparta/entrypoint-collector/sparta-default-entrypoint') +const { DI_METHOD_NAMES } = require('./haodf-mvc-controller-entrypoint') + +const MAX_DEPTH = 10 + +/** DataBucket 基类名模式（大小写不敏感，endsWith 匹配） */ +const DATABUCKET_BASE_PATTERNS = ['basedatabucket', 'databucket', 'basedatabacket', 'databacket'] + +/** DataBucket 类名后缀（大小写不敏感，endsWith 匹配）。历史拼写漂移允许 4 种。 */ +const DATABUCKET_SUFFIXES = ['databucket', 'databacket', 'databuck', 'bucket'] + +/** 基类名——跳过基类本身不当 entrypoint 采集 */ +const DATABUCKET_BASE_CLASSES = new Set([ + 'basedatabucket', + 'databucket', + 'basedatabacket', + 'databacket', +]) + +/** + * 判断 className 是否为 DataBucket 类 + * 条件：类名以 DATABUCKET_SUFFIXES 之一结尾（大小写不敏感），或继承链包含相应基类 + */ +function isDataBucketClass( + className: string, + inheritanceMap: Map>, + visited?: Set +): boolean { + const lowerName = className.toLowerCase() + + if (DATABUCKET_SUFFIXES.some((s) => lowerName.endsWith(s))) return true + + if (!visited) visited = new Set() + if (visited.has(className) || visited.size >= MAX_DEPTH) return false + visited.add(className) + + const parents = inheritanceMap.get(className) + if (!parents) return false + for (const parent of parents) { + const lowerParent = parent.toLowerCase() + if (DATABUCKET_BASE_PATTERNS.some((p) => lowerParent.endsWith(p))) return true + if (isDataBucketClass(parent, inheritanceMap, visited)) return true + } + return false +} + +/** + * 判断方法是否为合法的 DataBucket 业务方法 + * - 非魔术 / 非 DI 模板 + * - public 或默认（PHP 默认 public） + * - 参数数 >= 1 + */ +function isDataBucketMethod(funcDef: any): boolean { + const name = funcDef.id?.name + if (!name) return false + if (EXCLUDED_METHODS.has(name)) return false + if (DI_METHOD_NAMES.has(name.toLowerCase())) return false + + const modifiers: any[] = funcDef.modifiers || [] + for (const m of modifiers) { + const kw = typeof m === 'string' ? m : m?.name || m?.value || m?.kind + if (!kw) continue + const lower = String(kw).toLowerCase() + if (lower === 'private' || lower === 'protected' || lower === 'abstract') return false + } + + const params = funcDef.parameters || funcDef.params + if (!params || params.length < 1) return false + return true +} + +/** + * 采集入口 + * @param analyzer PhpAnalyzer 实例 + * @param dir 项目根目录 + */ +function findHaodfDataBucketEntryPoints(analyzer: any, dir: string): any[] { + const entryPoints: any[] = [] + const moduleScopes: Map = analyzer.moduleScopes || new Map() + + if (moduleScopes.size === 0) return entryPoints + + const inheritanceMap = buildClassInheritanceMap(moduleScopes) + + for (const [filename, modClos] of moduleScopes) { + if (!modClos?.value) continue + const shortFileName = extractRelativePath(filename, dir) + + for (const key of Object.keys(modClos.value)) { + const classVal = modClos.value[key] + const cdef = classVal?.ast?.cdef + if (!cdef || cdef.type !== 'ClassDefinition') continue + + const className = cdef.id?.name + if (!className) continue + if (!isDataBucketClass(className, inheritanceMap)) continue + + // 跳过基类本身 + const lowerName = className.toLowerCase() + if (DATABUCKET_BASE_CLASSES.has(lowerName)) continue + + const body = Array.isArray(cdef.body) ? cdef.body : cdef.body?.body + if (!body) continue + + for (const member of body) { + if (member.type !== 'FunctionDefinition') continue + if (!isDataBucketMethod(member)) continue + + const methodName = member.id.name + const methodFclos = classVal.value?.[methodName] + if (!methodFclos || methodFclos.vtype !== 'fclos') continue + + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = methodFclos.parent + ep.argValues = [] + ep.functionName = methodName + ep.filePath = shortFileName + ep.attribute = 'HaodfDataBucket' + ep.packageName = undefined + ep.entryPointSymVal = methodFclos + entryPoints.push(ep) + } + } + } + + logger.info(`[HaodfDataBucket] 发现 ${entryPoints.length} 个 DataBucket entrypoints`) + return entryPoints +} + +module.exports = { + findHaodfDataBucketEntryPoints, + isDataBucketClass, + isDataBucketMethod, +} diff --git a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts b/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts new file mode 100644 index 00000000..2bfbac28 --- /dev/null +++ b/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts @@ -0,0 +1,119 @@ +/** + * Haodf 自研 MVC 框架 Controller entrypoint 采集器（路由中立） + * + * 背景： + * - Haodf 自研 MVC（avatar 桶大多数项目）用 `mywebapp.php` 注册路由，但 `FixedRouterRule::create()->url('//')` + * catchall 兜底会把未在 NamedRouterRule 里注册的 public action 也调用到， + * 所以不能用路由白名单做准入门票（会漏），改走"类签名约定"。 + * + * 识别策略： + * 1. 类名以 `Controller` 结尾（大小写不敏感，如 `Indexcontroller`/`AuditInfocontroller`）， + * 或继承链包含 `BaseController`/`Controller`。 + * 2. 方法：public 非魔术，参数数 >= 1（Haodf 主流 action 签名为 `($request, $response)`， + * 但老代码存在 1 参和 3+ 参的真 action，只排 0 参）。 + * 3. 排除 PHP 魔术方法 / setInstance / getInstance / DI 模板。 + * + * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='HaodfMvcController'。 + * taint 层只把第一个参数 `$request` 当 source（`$response` 是输出端）。 + */ +const { extractRelativePath } = require('../../../../../util/file-util') +const EntryPoint = require('../../../common/entrypoint') +const Constant = require('../../../../../util/constant') +const logger = require('../../../../../util/logger')(__filename) +const { + buildClassInheritanceMap, + isControllerClass, + EXCLUDED_METHODS, +} = require('../../sparta/entrypoint-collector/sparta-default-entrypoint') + +/** 不作为 action 的 DI / 单例模板方法名（小写） */ +const DI_METHOD_NAMES = new Set(['setinstance', 'getinstance']) + +/** + * 判断方法是否为 Haodf MVC Controller 的合法 action + * - 非魔术 / 非 DI 模板 + * - public 或未显式修饰（PHP 默认 public） + * - 参数数 >= 1（0 参方法一般是工具函数，不采） + */ +function isMvcActionMethod(funcDef: any): boolean { + const name = funcDef.id?.name + if (!name) return false + if (EXCLUDED_METHODS.has(name)) return false + if (DI_METHOD_NAMES.has(name.toLowerCase())) return false + + const modifiers: any[] = funcDef.modifiers || [] + for (const m of modifiers) { + const kw = typeof m === 'string' ? m : m?.name || m?.value || m?.kind + if (!kw) continue + const lower = String(kw).toLowerCase() + if (lower === 'private' || lower === 'protected' || lower === 'abstract') return false + } + + const params = funcDef.parameters || funcDef.params + if (!params || params.length < 1) return false + return true +} + +/** + * 采集入口 + * @param analyzer PhpAnalyzer 实例 + * @param dir 项目根目录 + */ +function findHaodfMvcControllerEntryPoints(analyzer: any, dir: string): any[] { + const entryPoints: any[] = [] + const moduleScopes: Map = analyzer.moduleScopes || new Map() + + if (moduleScopes.size === 0) return entryPoints + + const inheritanceMap = buildClassInheritanceMap(moduleScopes) + + for (const [filename, modClos] of moduleScopes) { + if (!modClos?.value) continue + const shortFileName = extractRelativePath(filename, dir) + + for (const key of Object.keys(modClos.value)) { + const classVal = modClos.value[key] + const cdef = classVal?.ast?.cdef + if (!cdef || cdef.type !== 'ClassDefinition') continue + + const className = cdef.id?.name + if (!className) continue + if (!isControllerClass(className, inheritanceMap)) continue + + // 跳过基类本身（BaseController / Controller），它们没有业务 action + const lowerName = className.toLowerCase() + if (lowerName === 'basecontroller' || lowerName === 'controller') continue + + const body = Array.isArray(cdef.body) ? cdef.body : cdef.body?.body + if (!body) continue + + for (const member of body) { + if (member.type !== 'FunctionDefinition') continue + if (!isMvcActionMethod(member)) continue + + const methodName = member.id.name + const methodFclos = classVal.value?.[methodName] + if (!methodFclos || methodFclos.vtype !== 'fclos') continue + + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = methodFclos.parent + ep.argValues = [] + ep.functionName = methodName + ep.filePath = shortFileName + ep.attribute = 'HaodfMvcController' + ep.packageName = undefined + ep.entryPointSymVal = methodFclos + entryPoints.push(ep) + } + } + } + + logger.info(`[HaodfMvcController] 发现 ${entryPoints.length} 个 MVC Controller action entrypoints`) + return entryPoints +} + +module.exports = { + findHaodfMvcControllerEntryPoints, + isMvcActionMethod, + DI_METHOD_NAMES, +} diff --git a/src/engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint.ts b/src/engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint.ts new file mode 100644 index 00000000..95943ed9 --- /dev/null +++ b/src/engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint.ts @@ -0,0 +1,140 @@ +/** + * SOA Service 框架 entrypoint 采集器 + * + * SOA 服务模式： + * - 类名以 Svc / Service 结尾，或继承 *BaseService / *Service + * - 服务方法参数即为 RPC 用户输入，全部标记为 source + * - 排除已由 Sparta 处理的 Controller 类 + * + * 与 Sparta collector 不同，SOA collector 直接返回带 symVal 的完整 EntryPoint， + * 因为 PHP 类方法的 fclos 不在 context.funcs 中（除非重写父类方法）， + * resolveFrameworkEntryPoints 无法定位它们。 + */ +const { extractRelativePath } = require('../../../../../util/file-util') +const EntryPoint = require('../../../common/entrypoint') +const Constant = require('../../../../../util/constant') +const logger = require('../../../../../util/logger')(__filename) +const { + buildClassInheritanceMap, + isControllerClass, + EXCLUDED_METHODS, +} = require('../../sparta/entrypoint-collector/sparta-default-entrypoint') + +/** SOA Service 类名后缀（大小写不敏感匹配） */ +const SERVICE_SUFFIXES = ['svc', 'service'] + +/** Service 基类名模式（大小写不敏感匹配） */ +const SERVICE_BASE_PATTERNS = ['baseservice', 'service'] + +const MAX_DEPTH = 10 + +/** + * 判断 className 是否为 SOA Service 类 + * 条件：类名以 Svc/Service 结尾，或继承链中包含 *BaseService/*Service + * 排除 Controller 类（已由 Sparta 处理） + */ +function isServiceClass( + className: string, + inheritanceMap: Map>, + visited?: Set +): boolean { + // 排除 Controller 类 + if (isControllerClass(className, inheritanceMap)) return false + + const lowerName = className.toLowerCase() + + // 类名以 Svc 或 Service 结尾 + if (SERVICE_SUFFIXES.some((suffix) => lowerName.endsWith(suffix))) return true + + // 递归检查继承链 + if (!visited) visited = new Set() + if (visited.has(className) || visited.size >= MAX_DEPTH) return false + visited.add(className) + + const parents = inheritanceMap.get(className) + if (!parents) return false + for (const parent of parents) { + const lowerParent = parent.toLowerCase() + if (SERVICE_BASE_PATTERNS.some((pattern) => lowerParent.endsWith(pattern))) return true + if (isServiceClass(parent, inheritanceMap, visited)) return true + } + return false +} + +/** + * 判断方法是否为 SOA Service 方法 + * 条件：非魔术方法，有 >= 1 个参数 + */ +function isServiceMethod(funcDef: any): boolean { + const name = funcDef.id?.name + if (!name || EXCLUDED_METHODS.has(name)) return false + const params = funcDef.parameters || funcDef.params + if (!params || params.length < 1) return false + return true +} + +/** + * 从 analyzer 的 moduleScopes 中扫描 SOA Service 类，直接解析方法 fclos 为完整 entrypoints。 + * PHP 类方法的 fclos 存储在 classValue.value[methodName] 中（不在 context.funcs）， + * 所以此处直接从 class scope value 中获取 fclos，无需经过 resolveFrameworkEntryPoints。 + * + * @param analyzer PhpAnalyzer 实例 + * @param dir 项目根目录 + * @returns 完整的 EntryPoint 数组（带 entryPointSymVal） + */ +function findSoaServiceEntryPoints(analyzer: any, dir: string): any[] { + const entryPoints: any[] = [] + const moduleScopes: Map = analyzer.moduleScopes || new Map() + + if (moduleScopes.size === 0) return entryPoints + + const inheritanceMap = buildClassInheritanceMap(moduleScopes) + + for (const [filename, modClos] of moduleScopes) { + if (!modClos?.value) continue + const shortFileName = extractRelativePath(filename, dir) + + for (const key of Object.keys(modClos.value)) { + const classVal = modClos.value[key] + const cdef = classVal?.ast?.cdef + if (!cdef || cdef.type !== 'ClassDefinition') continue + + const className = cdef.id?.name + if (!className) continue + if (!isServiceClass(className, inheritanceMap)) continue + + // 扫描类体中的方法，直接从 classVal.value 中获取对应的 fclos + const body = Array.isArray(cdef.body) ? cdef.body : cdef.body?.body + if (!body) continue + + for (const member of body) { + if (member.type !== 'FunctionDefinition') continue + if (!isServiceMethod(member)) continue + + const methodName = member.id.name + // 从类 scope value 中获取方法的 fclos + const methodFclos = classVal.value?.[methodName] + if (!methodFclos || methodFclos.vtype !== 'fclos') continue + + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.scopeVal = methodFclos.parent + ep.argValues = [] + ep.functionName = methodName + ep.filePath = shortFileName + ep.attribute = 'SOAService' + ep.packageName = undefined + ep.entryPointSymVal = methodFclos + entryPoints.push(ep) + } + } + } + + logger.info(`[SoaServiceEntrypoint] 发现 ${entryPoints.length} 个 SOA Service entrypoints`) + return entryPoints +} + +module.exports = { + findSoaServiceEntryPoints, + isServiceClass, + isServiceMethod, +} diff --git a/src/engine/analyzer/php/sparta/entrypoint-collector/sparta-default-entrypoint.ts b/src/engine/analyzer/php/sparta/entrypoint-collector/sparta-default-entrypoint.ts new file mode 100644 index 00000000..936b361f --- /dev/null +++ b/src/engine/analyzer/php/sparta/entrypoint-collector/sparta-default-entrypoint.ts @@ -0,0 +1,157 @@ +/** + * Sparta 框架 entrypoint 采集器 + * + * Sparta 控制器模式： + * - 继承 Controller / BaseController / 任何以 Controller 结尾的类 + * - action 方法签名：public function actionName($request, $response) + * - 两个参数的方法被识别为 HTTP 入口 + */ +const { extractRelativePath } = require('../../../../../util/file-util') +const EntryPoint = require('../../../common/entrypoint') +const Constant = require('../../../../../util/constant') +const logger = require('../../../../../util/logger')(__filename) + +/** Controller 基类名模式 */ +const CONTROLLER_BASE_NAMES = ['Controller', 'BaseController'] +const CONTROLLER_SUFFIX = 'Controller' + +/** PHP 魔术方法和内部方法，不作为 entrypoint */ +const EXCLUDED_METHODS = new Set([ + '__construct', '__destruct', '__get', '__set', '__call', '__callStatic', + '__isset', '__unset', '__sleep', '__wakeup', '__toString', '__invoke', + '__clone', '__debugInfo', '__serialize', '__unserialize', +]) + +/** + * 从所有文件的 AST 中构建类继承关系 + */ +function buildClassInheritanceMap(moduleScopes: Map): Map> { + const inheritanceMap = new Map>() + + for (const [, modClos] of moduleScopes) { + if (!modClos?.value) continue + for (const key of Object.keys(modClos.value)) { + const val = modClos.value[key] + const cdef = val?.ast?.cdef + if (!cdef || cdef.type !== 'ClassDefinition') continue + + const className = cdef.id?.name + if (!className) continue + + if (!inheritanceMap.has(className)) { + inheritanceMap.set(className, new Set()) + } + const parents = inheritanceMap.get(className)! + + // supers 是父类列表 + if (Array.isArray(cdef.supers)) { + for (const s of cdef.supers) { + const parentName = s.type === 'Identifier' ? s.name : s.name || s.value + if (parentName) parents.add(parentName) + } + } + // 兼容 extends 字段 + if (cdef.extends) { + const extName = typeof cdef.extends === 'string' ? cdef.extends + : cdef.extends.name || cdef.extends.value + if (extName) parents.add(extName) + } + } + } + return inheritanceMap +} + +const MAX_DEPTH = 10 + +/** + * 递归检查 className 是否直接或间接继承自 Controller + */ +function isControllerClass( + className: string, + inheritanceMap: Map>, + visited?: Set +): boolean { + if (CONTROLLER_BASE_NAMES.includes(className)) return true + if (className.endsWith(CONTROLLER_SUFFIX)) return true + if (!visited) visited = new Set() + if (visited.has(className) || visited.size >= MAX_DEPTH) return false + visited.add(className) + const parents = inheritanceMap.get(className) + if (!parents) return false + for (const parent of parents) { + if (isControllerClass(parent, inheritanceMap, visited)) return true + } + return false +} + +/** + * 判断方法是否为 Sparta action 方法 + * 特征：非魔术方法，参数 >= 2（$request, $response） + */ +function isActionMethod(funcDef: any): boolean { + const name = funcDef.id?.name + if (!name || EXCLUDED_METHODS.has(name)) return false + // 参数数量 >= 2（$request, $response） + const params = funcDef.parameters || funcDef.params + if (!params || params.length < 2) return false + return true +} + +/** + * 从 analyzer 的 moduleScopes 中扫描 Sparta Controller，收集 action entrypoints + * + * @param analyzer PhpAnalyzer 实例 + * @param dir 项目根目录 + * @returns entrypoint 数组 + */ +function findSpartaEntryPoints(analyzer: any, dir: string): any[] { + const entryPoints: any[] = [] + const moduleScopes: Map = analyzer.moduleScopes || new Map() + + if (moduleScopes.size === 0) return entryPoints + + const inheritanceMap = buildClassInheritanceMap(moduleScopes) + + for (const [filename, modClos] of moduleScopes) { + if (!modClos?.value) continue + const shortFileName = extractRelativePath(filename, dir) + + for (const key of Object.keys(modClos.value)) { + const val = modClos.value[key] + const cdef = val?.ast?.cdef + if (!cdef || cdef.type !== 'ClassDefinition') continue + + const className = cdef.id?.name + if (!className) continue + + // 检查是否为 Controller 类 + if (!isControllerClass(className, inheritanceMap)) continue + + // 扫描类体中的方法 + const body = Array.isArray(cdef.body) ? cdef.body : cdef.body?.body + if (!body) continue + + for (const member of body) { + if (member.type !== 'FunctionDefinition') continue + if (!isActionMethod(member)) continue + + const methodName = member.id.name + const ep = new EntryPoint(Constant.ENGIN_START_FUNCALL) + ep.filePath = shortFileName + ep.functionName = methodName + ep.attribute = 'SpartaHTTP' + entryPoints.push(ep) + } + } + } + + logger.info(`[SpartaEntrypoint] 发现 ${entryPoints.length} 个 Controller action entrypoints`) + return entryPoints +} + +module.exports = { + findSpartaEntryPoints, + isControllerClass, + buildClassInheritanceMap, + EXCLUDED_METHODS, +} diff --git a/src/engine/analyzer/python/common/builtins/python-builtins.ts b/src/engine/analyzer/python/common/builtins/python-builtins.ts new file mode 100644 index 00000000..454bdb2a --- /dev/null +++ b/src/engine/analyzer/python/common/builtins/python-builtins.ts @@ -0,0 +1,100 @@ +/** + * Python 内建函数的 runtime.execute 注册 + * + * 仿 Java java-initializer.ts 模式，将 Python 内建函数（如 enumerate） + * 注册为 topScope 中带 runtime.execute 的 FunctionValue， + * 使引擎在 executeCall 时走内建执行路径而非 processLibArgToRet 兜底。 + */ +import { FunctionValue } from '../../../common/value/function' +import { SymbolValue } from '../../../common/value/symbolic' +import { PrimitiveValue } from '../../../common/value/primitive' +import type { Scoped } from '../../../common/value/scoped' +import type { State } from '../../../../../types/analyzer' + +/** + * enumerate 的 runtime.execute 实现 + * + * 将 iterable 包装为带 members{"0": index, "1": element} 的结构化值， + * 使 processRangeStatement 的 TupleExpression 解包能精确传播 taint。 + */ +function enumerateExecute( + this: any, + _fclos: FunctionValue, + argvalues: any[], + _state: State, + node: any, + _scope: any +): SymbolValue { + const iterable = argvalues[0] + const resultQid = `.enumerate` + + /* 构造返回值：SymbolValue 的 value 是一个对象， + * 键为数字字符串("0","1",...), 值为带 members 的 tuple 结构 */ + const resultValue: Record = {} + + if (iterable && typeof iterable.getRawValue === 'function') { + const rawFields = iterable.getRawValue() + let idx = 0 + for (const key in rawFields) { + if (typeof key === 'string' && key.includes('__yasa')) continue + if (typeof rawFields.hasOwnProperty === 'function' && rawFields.hasOwnProperty(key)) { + const element = rawFields[key] + /* 每个 tuple 项：members "0"=index, "1"=原始元素（保留 taint） */ + const tupleItem = new SymbolValue(resultQid, { + sid: `enumerate_item_${idx}`, + qid: `${resultQid}.item_${idx}`, + }) + tupleItem.members.set('0', new PrimitiveValue(resultQid, String(idx), idx, 'number')) + tupleItem.members.set('1', element) + resultValue[String(idx)] = tupleItem + idx++ + } + } + + /* iterable 没有可枚举字段时（如扁平 SymbolValue）， + * 生成单个 tuple 项将整个 iterable 作为元素传播 taint */ + if (idx === 0) { + const tupleItem = new SymbolValue(resultQid, { + sid: 'enumerate_item_0', + qid: `${resultQid}.item_0`, + }) + tupleItem.members.set('0', new PrimitiveValue(resultQid, '0', 0, 'number')) + tupleItem.members.set('1', iterable) + resultValue['0'] = tupleItem + } + } else if (iterable) { + /* iterable 不支持 getRawValue 时，兜底：将整体作为单元素 */ + const tupleItem = new SymbolValue(resultQid, { + sid: 'enumerate_item_0', + qid: `${resultQid}.item_0`, + }) + tupleItem.members.set('0', new PrimitiveValue(resultQid, '0', 0, 'number')) + tupleItem.members.set('1', iterable) + resultValue['0'] = tupleItem + } + + const result = new SymbolValue(resultQid, { + sid: 'enumerate_result', + qid: `${resultQid}.result`, + value: resultValue, + }) + + return result +} + +/** + * 在 topScope 中注册 Python 内建函数 + * + * 在 preProcess 阶段调用，确保符号解释前完成注册。 + */ +export function initPythonBuiltins(topScope: Scoped): void { + const builtinQid = `${topScope.qid}.` + + const enumFv = new FunctionValue('', { + sid: 'enumerate', + qid: `${builtinQid}.enumerate`, + parent: topScope, + }) + enumFv.runtime = { execute: enumerateExecute } + topScope.value['enumerate'] = enumFv +} diff --git a/src/engine/analyzer/python/common/entrypoint-collector/python-entrypoint.ts b/src/engine/analyzer/python/common/entrypoint-collector/python-entrypoint.ts index 188378b0..5d05fbf8 100644 --- a/src/engine/analyzer/python/common/entrypoint-collector/python-entrypoint.ts +++ b/src/engine/analyzer/python/common/entrypoint-collector/python-entrypoint.ts @@ -5,6 +5,7 @@ const { findInferenceTritonEntryPointAndSource, } = require('../../inference/entrypoint-collector/inference-default-entrypoint') const { findMcpEntryPointAndSource } = require('../../mcp/entrypoint-collector/mcp-default-entrypoint') +const { findHttpServerEntryPointAndSource } = require('../../httpserver/entrypoint-collector/httpserver-entrypoint') const BasicRuleHandler = require('../../../../../checker/common/rules-basic-handler') const { loadPythonDefaultRule } = require('../../../../../checker/taint/python/python-taint-abstract-checker') const AstUtil = require('../../../../../util/ast-util') @@ -27,12 +28,13 @@ function findPythonFcEntryPointAndSource(dir: string, fileManager: FileManager, const pyFcEntryPointSourceArray: any[] = [] const filenameAstObj: Record = {} for (const filename in fileManager) { - const modClos = analyzer.symbolTable.get(fileManager[filename]) - if (modClos.ast?.node?._meta?.nodehash !== undefined) { - filenameAstObj[filename] = modClos.ast?.node + const fileEntry = fileManager[filename] + if (fileEntry?.astNode?._meta?.nodehash !== undefined) { + filenameAstObj[filename] = fileEntry.astNode } } + const { flaskEntryPointArray, flaskEntryPointSourceArray } = findFlaskEntryPointAndSource(filenameAstObj, dir) if (flaskEntryPointArray) { pyFcEntryPointArray.push(...flaskEntryPointArray) @@ -75,6 +77,17 @@ function findPythonFcEntryPointAndSource(dir: string, fileManager: FileManager, pyFcEntryPointSourceArray.push(...mcpEntryPointSourceArray) } + const { httpServerEntryPointArray, httpServerEntryPointSourceArray } = findHttpServerEntryPointAndSource( + filenameAstObj, + dir + ) + if (httpServerEntryPointArray) { + pyFcEntryPointArray.push(...httpServerEntryPointArray) + } + if (httpServerEntryPointSourceArray) { + pyFcEntryPointSourceArray.push(...httpServerEntryPointSourceArray) + } + return { pyFcEntryPointArray, pyFcEntryPointSourceArray } } diff --git a/src/engine/analyzer/python/common/python-analyzer.ts b/src/engine/analyzer/python/common/python-analyzer.ts index 4fefb6d8..13aa764a 100644 --- a/src/engine/analyzer/python/common/python-analyzer.ts +++ b/src/engine/analyzer/python/common/python-analyzer.ts @@ -1,5 +1,6 @@ import type { Instruction } from '@ant-yasa/uast-spec' import SymAddress from '../../common/sym-address' +import { AstRefList } from '../../common/value/ast-ref-list' import { BinaryExprValue } from '../../common/value/binary-expr' import type { Scope, @@ -19,12 +20,13 @@ import type { MemberAccess, NewExpression, ReturnStatement, + TryStatement, VariableDeclaration, AssignmentExpression, + SpreadElement, } from '../../../../types/uast' const Uuid = require('node-uuid') -const { floor } = require('lodash') const globby = require('fast-glob') const _ = require('lodash') const path = require('path') @@ -270,6 +272,23 @@ class PythonAnalyzer extends Analyzer { this.checkerManager.checkAtSymbolInterpretOfEntryPointAfter(this, null, null, null, null) } + /** + * Python 的 **kwargs spread 在函数调用参数中需要保留 dict 的 key→value 结构， + * 基类 processSpreadElement 会将 dict 展平为独立值的 Set 丢失键名， + * 导致 resolveKwSpreadEntries 无法还原 keyword 参数绑定。 + * 仅对函数调用参数直接求值内部引用，返回完整的 ObjectValue； + * dict literal 中的 {**params} 仍走基类展平逻辑。 + * @param scope + * @param node + * @param state + */ + override processSpreadElement(scope: Scope, node: SpreadElement, state: State): any { + if ((node as any).parent?.type === 'CallExpression') { + return this.processInstruction(scope, node.argument, state) + } + return super.processSpreadElement(scope, node, state) + } + /** * * @param scope @@ -344,6 +363,53 @@ class PythonAnalyzer extends Analyzer { }) } + // union callee 含 class 成员：拆出 class 走 propagateNewObject，其余交给 executeCall + if (fclos.vtype === 'union' && Array.isArray(fclos.value)) { + const classMembers = fclos.value.filter((m: any) => m && typeof m === 'object' && m.vtype === 'class') + if (classMembers.length > 0) { + const results: Value[] = [] + for (const member of classMembers) { + const signatureAst = member.members?.get('_CTOR_')?.fdef || member.fdef || member.ast + if (signatureAst?.type === 'FunctionDefinition') { + callInfo.boundCall = this.bindCallArgs(node, member, signatureAst, callInfo) + } + const r = this.propagateNewObject(scope, node, state, member, argvalues, callInfo) + if (r) results.push(r) + } + // 非 class 成员通过 executeCall 的 union 处理（已内置 checkAtFunctionCallAfter） + const nonClassMembers = fclos.value.filter((m: any) => !m || typeof m !== 'object' || m.vtype !== 'class') + if (nonClassMembers.length > 0) { + for (const member of nonClassMembers) { + if (!member || typeof member !== 'object') continue + const r = this.executeCall(node, member, state, scope, callInfo) + if (r) { + results.push(r) + if (this.checkerManager?.checkAtFunctionCallAfter) { + this.checkerManager.checkAtFunctionCallAfter(this, scope, node, state, { + callInfo, + fclos: member, + ret: r, + pcond: state.pcond, + einfo: state.einfo, + callstack: state.callstack, + }) + } + } + } + } + if (results.length === 1) return results[0] + if (results.length > 1) { + return new UnionValue( + results, + undefined, + `${scope.qid}.`, + node + ) + } + return new UndefinedValue() + } + } + if (fclos.vtype === 'class') { const signatureAst = fclos?.members?.get('_CTOR_')?.fdef || fclos?.fdef || fclos?.ast if (signatureAst?.type === 'FunctionDefinition') { @@ -351,14 +417,31 @@ class PythonAnalyzer extends Analyzer { } return this.propagateNewObject(scope, node, state, fclos, argvalues, callInfo) } - // todo 待迁移到库函数建模中 + // list.append(x)：将元素添加到列表，并传播污点 if ( node.callee.type === 'MemberAccess' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'append' && - (fclos as any)?.object?.parent + (fclos as any)?.object ) { - this.saveVarInCurrentScope((fclos as any).object.parent, fclos.object, argvalues[0], state) + const listObj = (fclos as any).object + const appendedVal = argvalues[0] + if (appendedVal) { + // 将元素存入列表的下一个索引位置 + const nextIdx = + listObj.length ?? + Object.keys(listObj.getRawValue?.() ?? {}).filter((k: string) => !k.startsWith('__yasa')).length + if (listObj.value && typeof listObj.value === 'object') { + listObj.value[nextIdx] = appendedVal + } + if (typeof listObj.length === 'number') { + listObj.length++ + } + // 传播污点：如果追加的元素有污点，列表也应该有污点 + if (appendedVal._taint?.isTaintedRec) { + listObj.taint.propagateFrom(appendedVal) + } + } return undefined } const res = this.executeCall(node, fclos, state, scope, callInfo) @@ -398,7 +481,9 @@ class PythonAnalyzer extends Analyzer { argvalues: Value[], callInfo: CallInfo ): Value { - if (fclos.members?.has('_CTOR_')) { + // 有 __init__ 或 __new__：走完整 buildNewObject（执行构造函数） + // 不含 fclos.ast?.cdef 条件——无 __init__ 的类走 processLibArgToRet 避免 OOM + if (fclos.members?.has('_CTOR_') || fclos.value?.['__new__']) { const res = this.buildNewObject(fclos.ast.cdef, fclos, state, node, scope, callInfo) if (res && this.checkerManager?.checkAtFunctionCallAfter) { this.checkerManager.checkAtFunctionCallAfter(this, scope, node, state, { @@ -737,8 +822,19 @@ class PythonAnalyzer extends Analyzer { } if (!resolved_prop) return defscope const res = this.getMemberValue(defscope, resolved_prop, state) - if (node.object.type !== 'SuperExpression' && (res.vtype !== 'union' || !Array.isArray(res.value))) { - res._this = defscope + if (node.object.type !== 'SuperExpression') { + if (res.vtype !== 'union' || !Array.isArray(res.value)) { + // 非 union 类型：直接绑定 _this + res._this = defscope + } else { + // union + 数组：在 union 层级设置 _this，同时为每个尚未绑定 _this 的子成员设置 + res._this = defscope + for (const member of res.value) { + if (member && typeof member === 'object' && !member._this) { + member._this = defscope + } + } + } } else if (node.object.type === 'SuperExpression' && this.thisFClos) { // For super().method() calls, bind this/self to the current instance. // In Python semantics, super() only affects method dispatch, not self binding. @@ -757,7 +853,6 @@ class PythonAnalyzer extends Analyzer { */ processModule(ast: any, filename: any) { if (!ast) { - process.exitCode = ErrorCode.fail_to_parse const sourceFile = filename Stat.fileIssues[sourceFile] = 'Parsing Error' handleException( @@ -779,7 +874,7 @@ class PythonAnalyzer extends Analyzer { const modClos = new Scoped(this.topScope.qid, { sid: relateFileName, parent: this.topScope, decls: {}, ast }) modClos.ast.fdef = ast this.topScope.context.modules.members.set(filename, modClos) - this.fileManager[filename] = modClos.uuid + this.fileManager[filename] = { uuid: modClos.uuid, astNode: modClos.ast.node } m = this.processModuleDirect(ast, filename, modClos) ;(m as any).ast = ast return m @@ -875,7 +970,6 @@ class PythonAnalyzer extends Analyzer { } /** - * * @param scope * @param node * @param state @@ -886,7 +980,7 @@ class PythonAnalyzer extends Analyzer { if (!node.isYield) { if (!(this as any).lastReturnValue) { ;(this as any).lastReturnValue = return_value - } else if ((this as any).lastReturnValue.vtype === 'union') { + } else if ((this as any).lastReturnValue.vtype === 'union' && !(this as any).lastReturnValue.isTuple) { ;(this as any).lastReturnValue.appendValue(return_value) } else { const tmp = new UnionValue(undefined, undefined, `${scope.qid}.`, node) @@ -910,6 +1004,58 @@ class PythonAnalyzer extends Analyzer { return new PrimitiveValue(scope.qid, 'undefined', null, null, 'Literal', node.loc) } + /** + * Python try-except 覆盖：except handler 通过 getDefScope 向上覆盖 try body 设置的绑定 + * + * 问题根因：基类为 except handler 创建子 scope，但赋值通过 getDefScope 向上查找到 + * 父 scope 同名变量并覆盖（如 try-import/except-None 模式）。 + * + * 修复策略：保存 try body 后的值快照，except handler 处理后，对被覆盖的变量创建 + * union（try 值 | except 值），由 processCallExpression 的 union 遍历处理调用。 + * @param scope + * @param node + * @param state + */ + override processTryStatement(scope: Scope, node: TryStatement, state: State): VoidValueType { + this.processInstruction(scope, node.body, state) + + const { handlers } = node + if (handlers && handlers.length > 0) { + // 保存 try body 后的 scope 值快照 + const trySnapshot: Record = {} + if (scope.value) { + for (const key of Object.keys(scope.value)) { + trySnapshot[key] = scope.value[key] + } + } + + for (const clause of handlers) { + if (!clause) continue + const exceptScope = ScopeClass.createSubScope( + ``, + scope + ) + clause.parameter.forEach((param: any) => this.processInstruction(exceptScope, param, state)) + this.processInstruction(exceptScope, clause.body, state) + } + + // except handler 可能通过 getDefScope 覆盖了父 scope 的绑定 + // 对被覆盖的变量创建 union（try 值 | except 值），保留两条路径的分析能力 + if (scope.value) { + for (const key of Object.keys(trySnapshot)) { + const tryVal = trySnapshot[key] + const exceptVal = scope.value[key] + if (tryVal && exceptVal && tryVal !== exceptVal) { + scope.value[key] = new UnionValue([tryVal, exceptVal], undefined, `${scope.qid}.${key}`, tryVal.ast) + } + } + } + } + + if (node.finalizer) this.processInstruction(scope, node.finalizer, state) + return new UndefinedValue() + } + /** * * @param scope @@ -1069,7 +1215,6 @@ class PythonAnalyzer extends Analyzer { } if (this.checkerManager && this.checkerManager.checkAtAssignment) { const lscope = this.getDefScope(scope, left) - const mindex = this.resolveIndices(scope, left, state) this.checkerManager.checkAtAssignment(this, scope, node, state, { lscope, lvalue: oldVal, @@ -1077,7 +1222,6 @@ class PythonAnalyzer extends Analyzer { pcond: state.pcond, binfo: state.binfo, entry_fclos: this.entry_fclos, - mindex, einfo: state.einfo, state, ainfo: this.ainfo, @@ -1125,7 +1269,6 @@ class PythonAnalyzer extends Analyzer { if (this.checkerManager && this.checkerManager.checkAtAssignment) { const lscope = this.getDefScope(scope, node.left) - const mindex = this.resolveIndices(scope, node.left, state) this.checkerManager.checkAtAssignment(this, scope, node, state, { lscope, lvalue: oldVal, @@ -1133,7 +1276,6 @@ class PythonAnalyzer extends Analyzer { pcond: state.pcond, binfo: state.binfo, entry_fclos: this.entry_fclos, - mindex, einfo: state.einfo, state, ainfo: this.ainfo, @@ -1155,17 +1297,33 @@ class PythonAnalyzer extends Analyzer { */ handleTupleAssign(scope: any, left: any, rightVal: any, state: any) { if (rightVal.vtype === 'union') { - const pairs = floor(rightVal.value.length / left.elements.length) - const scopes = new Array(left.elements.length) - for (let i = 0; i < left.elements.length; i++) scopes[i] = new Array(pairs) - for (let i = 0; i < pairs; i++) { - for (let j = 0; j < left.elements.length; j++) { - scopes[j][i] = rightVal.value[i * left.elements.length + j] + if (rightVal.isTuple) { + // 直接 tuple：按索引 1-to-1 拆分 + const minLen = Math.min(left.elements.length, rightVal.value.length) + for (let i = 0; i < minLen; i++) { + this.saveVarInScope(scope, left.elements[i], rightVal.value[i], state) + } + } else { + // union-of-returns：每个元素可能是 tuple 或单值，按位置提取后合并 + const leftCount = left.elements.length + const perPos: any[][] = Array.from({ length: leftCount }, () => []) + for (const elem of rightVal.value) { + if (elem && elem.isTuple && elem.vtype === 'union') { + // 某个 return 分支的 tuple，按位置提取 + for (let j = 0; j < leftCount; j++) { + perPos[j].push(j < elem.value.length ? elem.value[j] : elem) + } + } else { + // 非 tuple 值（单值 return），保守分配到所有位置 + for (let j = 0; j < leftCount; j++) { + perPos[j].push(elem) + } + } + } + for (let i = 0; i < leftCount; i++) { + const union = unionAllValues(perPos[i], state) + this.saveVarInScope(scope, left.elements[i], union, state) } - } - for (let i = 0; i < left.elements.length; i++) { - const union = unionAllValues(scopes[i], state) - this.saveVarInScope(scope, left.elements[i], union, state) } } else if (Array.isArray(rightVal.value) && rightVal.value.length >= 1) { const minLen = Math.min(left.elements.length, rightVal.value.length) @@ -1266,7 +1424,7 @@ class PythonAnalyzer extends Analyzer { if (path.basename(filename) === '__init__.py') { // 先注册到 members 再处理，防止递归 import 重复触发 processModuleDirect this.topScope.context.modules.members.set(filename, packageScope) - this.fileManager[filename] = packageScope.uuid + this.fileManager[filename] = { uuid: packageScope.uuid, astNode: packageScope.ast.node } const m = this.processModuleDirect(ast, filename, packageScope) ;(m as any).ast = ast return m @@ -1379,6 +1537,9 @@ class PythonAnalyzer extends Analyzer { if (fieldName === '_CTOR_') { superValue.ast.node = v_copy.ast.fdef superValue.ast.fdef = v_copy.ast.fdef + if (!superValue.overloaded) { + superValue.overloaded = new AstRefList(() => superValue.getASTManager()) + } superValue.overloaded.push(fdef) } } @@ -1435,7 +1596,8 @@ class PythonAnalyzer extends Analyzer { 'find no target compileUnit of the project : no python file found in source path', 'find no target compileUnit of the project : no python file found in source path' ) - process.exit(1) + process.exitCode = ErrorCode.no_valid_source_file + return } // 预先填充 sourceCodeCache，避免 parseProject 中的 postProcessProjectResult 重复读取 @@ -1466,6 +1628,10 @@ class PythonAnalyzer extends Analyzer { if (ast) { this.processModule(ast, filename) } + // 每个文件处理完后触发 checker 回调，用于逐步解析 pending 的 include() + if (this.checkerManager && this.checkerManager.checkAtEndOfCompileUnit) { + this.checkerManager.checkAtEndOfCompileUnit(this, null, null, null, null) + } } this.performanceTracker.end('preProcess.processModule') } diff --git a/src/engine/analyzer/python/fastapi/entrypoint-collector/fastapi-entrypoint.ts b/src/engine/analyzer/python/fastapi/entrypoint-collector/fastapi-entrypoint.ts index 0e74d408..9d6460c1 100644 --- a/src/engine/analyzer/python/fastapi/entrypoint-collector/fastapi-entrypoint.ts +++ b/src/engine/analyzer/python/fastapi/entrypoint-collector/fastapi-entrypoint.ts @@ -192,11 +192,13 @@ function processDecorator( if (!isValidRouter) return - // Create entrypoint + // 创建 entrypoint，携带函数定义行号用于精确匹配 overloaded 同名函数 const entryPoint = new EntryPointClass(Constant.ENGIN_START_FUNCALL) entryPoint.filePath = relativeFile entryPoint.functionName = funcName entryPoint.attribute = 'HTTP' + entryPoint.funcLocStart = obj.loc?.start?.line as number | undefined + entryPoint.funcLocEnd = obj.loc?.end?.line as number | undefined entryPoints.push(entryPoint) diff --git a/src/engine/analyzer/python/flask/entrypoint-collector/flask-default-entrypoint.ts b/src/engine/analyzer/python/flask/entrypoint-collector/flask-default-entrypoint.ts index 549e1df7..f566805d 100644 --- a/src/engine/analyzer/python/flask/entrypoint-collector/flask-default-entrypoint.ts +++ b/src/engine/analyzer/python/flask/entrypoint-collector/flask-default-entrypoint.ts @@ -122,6 +122,9 @@ function findFlaskEntryPointAndSource(filenameAstObj: FilenameAstMap, dir: strin entryPoint.filePath = shortFileName entryPoint.functionName = funcName entryPoint.attribute = 'HTTP' + // 携带函数定义行号，用于精确匹配 overloaded 同名函数 + entryPoint.funcLocStart = obj.loc?.start?.line as number | undefined + entryPoint.funcLocEnd = obj.loc?.end?.line as number | undefined flaskEntryPointArray.push(entryPoint) if (entryPointAndSourceAtSameTime) { diff --git a/src/engine/analyzer/python/httpserver/entrypoint-collector/httpserver-entrypoint.ts b/src/engine/analyzer/python/httpserver/entrypoint-collector/httpserver-entrypoint.ts new file mode 100644 index 00000000..a82fe3f3 --- /dev/null +++ b/src/engine/analyzer/python/httpserver/entrypoint-collector/httpserver-entrypoint.ts @@ -0,0 +1,253 @@ +const { extractRelativePath } = require('../../../../../util/file-util') +const EntryPoint = require('../../../common/entrypoint') +const Constant = require('../../../../../util/constant') + +// Python http.server / socketserver 框架的 HTTP handler 基类名 +export const HTTP_HANDLER_BASE_NAMES = [ + 'BaseHTTPRequestHandler', + 'SimpleHTTPRequestHandler', + 'CGIHTTPRequestHandler', + 'StreamRequestHandler', + 'BaseRequestHandler', +] + +// Python http.server 框架的 HTTP server 基类名（用于检测 server 类的 __init__ 入口） +export const HTTP_SERVER_BASE_NAMES = [ + 'HTTPServer', + 'BaseHTTPServer', + 'ThreadingHTTPServer', + 'TCPServer', + 'UDPServer', + 'ThreadingTCPServer', + 'ThreadingUDPServer', + 'ForkingTCPServer', + 'ForkingUDPServer', +] + +// do_METHOD 模式及 handle 方法 +export const HTTP_HANDLER_METHODS = [ + 'do_GET', + 'do_POST', + 'do_PUT', + 'do_DELETE', + 'do_PATCH', + 'do_HEAD', + 'do_OPTIONS', + 'do_CONNECT', + 'do_TRACE', + 'handle', +] + +const MAX_INHERITANCE_DEPTH = 10 + +interface ASTObject { + body?: any[] + [key: string]: any +} + +interface FilenameAstMap { + [filename: string]: ASTObject +} + +interface ClassInfo { + node: any + className: string + superNames: string[] +} + +/** + * 递归从 AST 节点中收集所有 ClassDefinition（含嵌套在函数/类内的定义） + */ +function collectAllClassDefinitions(node: any, result: ClassInfo[]): void { + if (!node || typeof node !== 'object') return + + if (Array.isArray(node)) { + for (const item of node) { + collectAllClassDefinitions(item, result) + } + return + } + + if (node.type === 'ClassDefinition') { + const className: string | undefined = node.id?.name + if (className && Array.isArray(node.supers)) { + const superNames: string[] = node.supers + .filter((s: any) => s.type === 'Identifier' && s.name) + .map((s: any) => s.name as string) + result.push({ node, className, superNames }) + } + if (Array.isArray(node.body)) { + collectAllClassDefinitions(node.body, result) + } + return + } + + if (Array.isArray(node.body)) { + collectAllClassDefinitions(node.body, result) + } + if (node.body && typeof node.body === 'object' && !Array.isArray(node.body)) { + collectAllClassDefinitions(node.body, result) + } +} + +/** + * 从 ClassInfo 列表构建继承关系 Map + */ +function buildInheritanceMapFromClasses(classes: ClassInfo[]): Map> { + const inheritanceMap = new Map>() + for (const { className, superNames } of classes) { + if (!inheritanceMap.has(className)) { + inheritanceMap.set(className, new Set()) + } + const parents = inheritanceMap.get(className)! + for (const s of superNames) { + parents.add(s) + } + } + return inheritanceMap +} + +/** + * 递归检查 className 是否直接或间接继承自 HTTP handler 基类 + */ +export function isHttpHandlerSubclass( + className: string, + inheritanceMap: Map>, + visited?: Set +): boolean { + if (HTTP_HANDLER_BASE_NAMES.includes(className)) return true + if (!visited) visited = new Set() + if (visited.has(className) || visited.size >= MAX_INHERITANCE_DEPTH) return false + visited.add(className) + const parents = inheritanceMap.get(className) + if (!parents) return false + for (const parent of parents) { + if (isHttpHandlerSubclass(parent, inheritanceMap, visited)) return true + } + return false +} + +/** + * 检查运行时的类符号值是否是 HTTP handler 子类（基于 AST 的父类名） + * 用于动态检测时判断函数返回值是否是 HTTP handler 类 + */ +export function isHttpHandlerClass(cls: any): boolean { + if (!cls || (cls.vtype !== 'class' && cls.vtype !== 'scope')) return false + const cdef = cls.ast?.cdef || cls.ast?.node + if (!cdef || cdef.type !== 'ClassDefinition') return false + const supers: string[] = (cdef.supers || []) + .filter((s: any) => s.type === 'Identifier' && s.name) + .map((s: any) => s.name as string) + // 直接继承检查（不需要全局继承图，只检查直接父类） + return supers.some((s) => HTTP_HANDLER_BASE_NAMES.includes(s)) +} + +/** + * 从 AST 文件级别检测包含 HTTP handler 类的文件 + * 返回文件相对路径列表（用于添加 file-begin 入口点） + */ +export function findFilesWithHttpHandlers(filenameAstObj: FilenameAstMap, dir: string): string[] { + const result: string[] = [] + for (const filename in filenameAstObj) { + const ast = filenameAstObj[filename] + if (!ast) continue + + const allClasses: ClassInfo[] = [] + collectAllClassDefinitions(ast, allClasses) + const inheritanceMap = buildInheritanceMapFromClasses(allClasses) + + const hasHttpHandler = allClasses.some(({ className }) => isHttpHandlerSubclass(className, inheritanceMap)) + if (hasHttpHandler) { + result.push(filename) + } + } + return result +} + +/** + * 检查 className 是否直接或间接继承自 HTTP server 基类（如 HTTPServer） + */ +function isHttpServerSubclass( + className: string, + inheritanceMap: Map>, + visited?: Set +): boolean { + if (HTTP_SERVER_BASE_NAMES.includes(className)) return true + if (!visited) visited = new Set() + if (visited.has(className) || visited.size >= MAX_INHERITANCE_DEPTH) return false + visited.add(className) + const parents = inheritanceMap.get(className) + if (!parents) return false + for (const parent of parents) { + if (isHttpServerSubclass(parent, inheritanceMap, visited)) return true + } + return false +} + +/** + * 从 AST 中收集顶层 ClassDefinition（不深入嵌套，因为 lookupFclos 只索引顶层方法） + */ +function collectTopLevelClassDefinitions(ast: ASTObject): ClassInfo[] { + const result: ClassInfo[] = [] + const body = Array.isArray(ast.body) ? ast.body : [] + for (const node of body) { + if (node.type === 'ClassDefinition' && node.id?.name && Array.isArray(node.supers)) { + const superNames: string[] = node.supers + .filter((s: any) => s.type === 'Identifier' && s.name) + .map((s: any) => s.name as string) + result.push({ node, className: node.id.name, superNames }) + } + } + return result +} + +/** + * 检测继承自 HTTPServer 的类，注册其 __init__ 为 FUNCALL 入口点 + * 用于让分析器进入 server 类的 __init__，从而发现 handler 类的动态注册 + */ +export function findHttpServerEntryPointAndSource( + filenameAstObj: FilenameAstMap, + dir: string +): { httpServerEntryPointArray: any[]; httpServerEntryPointSourceArray: any[] } { + const httpServerEntryPointArray: any[] = [] + const httpServerEntryPointSourceArray: any[] = [] + + // 构建跨文件继承关系（仅顶层类） + const inheritanceMap = new Map>() + for (const filename in filenameAstObj) { + const ast = filenameAstObj[filename] + if (!ast) continue + const topClasses = collectTopLevelClassDefinitions(ast) + for (const { className, superNames } of topClasses) { + if (!inheritanceMap.has(className)) { + inheritanceMap.set(className, new Set()) + } + const parents = inheritanceMap.get(className)! + for (const s of superNames) { + parents.add(s) + } + } + } + + for (const filename in filenameAstObj) { + const ast = filenameAstObj[filename] + if (!ast) continue + const shortFileName = extractRelativePath(filename, dir) + const topClasses = collectTopLevelClassDefinitions(ast) + + for (const { className, superNames, node } of topClasses) { + // 跳过直接就是 HTTPServer 基类的 + if (HTTP_SERVER_BASE_NAMES.includes(className)) continue + if (!isHttpServerSubclass(className, inheritanceMap)) continue + + // 注册 __init__ 为入口点（如 PolicyServerInput.__init__） + const entryPoint = new EntryPoint(Constant.ENGIN_START_FUNCALL) + entryPoint.filePath = shortFileName + entryPoint.functionName = '__init__' + entryPoint.attribute = 'HTTP' + httpServerEntryPointArray.push(entryPoint) + } + } + + return { httpServerEntryPointArray, httpServerEntryPointSourceArray } +} diff --git a/src/engine/analyzer/python/inference/entrypoint-collector/inference-default-entrypoint.ts b/src/engine/analyzer/python/inference/entrypoint-collector/inference-default-entrypoint.ts index b3edc5c3..d86dea9e 100644 --- a/src/engine/analyzer/python/inference/entrypoint-collector/inference-default-entrypoint.ts +++ b/src/engine/analyzer/python/inference/entrypoint-collector/inference-default-entrypoint.ts @@ -52,6 +52,9 @@ function findInferenceAiStudioTplEntryPointAndSource(filenameAstObj: Record) { options = options || {} if (options.language && options.language !== LanguageType.LANG_GO && options.language !== 'golang') { - handleException( - new Error(`Go AST Builder received wrong language type: ${options.language}`), - `Error: Go AST Builder received wrong language type: ${options.language}`, - `Error: Go AST Builder received wrong language type: ${options.language}` - ) - process.exit(1) + throw new Error(`Go AST Builder received wrong language type: ${options.language}`) } let isSingle = '' @@ -43,12 +38,7 @@ function buildUASTGo(rootDir: any, options: Record) { // if uast4goPath does not exist, exit with error if (!uast4go_path || !fs.existsSync(uast4go_path)) { - handleException( - null, - `uast4go not found. Please set --uastSDKPath to the binary or deps directory, or install it under deps/uast4go/uast4go`, - `uast4go not found. Please set --uastSDKPath to the binary or deps directory, or install it under deps/uast4go/uast4go` - ) - process.exit(1) + throw new Error('uast4go binary not found, please check uastSDKPath configuration') } if (options.ASTFileOutput) { diff --git a/src/engine/parser/java/java-ast-builder.ts b/src/engine/parser/java/java-ast-builder.ts index 5bbcfb78..817dd0dd 100644 --- a/src/engine/parser/java/java-ast-builder.ts +++ b/src/engine/parser/java/java-ast-builder.ts @@ -18,12 +18,7 @@ const uastParser = new UastParser() function parseJava(code: string, options?: ParseOptions) { options = options || {} if (options.language && options.language !== LanguageType.LANG_JAVA && options.language !== 'java') { - handleException( - new Error(`Java AST Builder received wrong language type: ${options.language}`), - `Error: Java AST Builder received wrong language type: ${options.language}`, - `Error: Java AST Builder received wrong language type: ${options.language}` - ) - process.exit(1) + throw new Error(`Java AST Builder received wrong language type: ${options.language}`) } options.language = LanguageType.LANG_JAVA return uastParser.parse(code, options) diff --git a/src/engine/parser/parser-core.ts b/src/engine/parser/parser-core.ts index 17506830..b3dbf326 100644 --- a/src/engine/parser/parser-core.ts +++ b/src/engine/parser/parser-core.ts @@ -9,7 +9,9 @@ const AstUtil = require('../../util/ast-util') const SourceLine = require('../analyzer/common/source-line') const { Errors } = require('../../util/error-code') const { addNodeHash } = require('../../util/ast-util') +const { getGlobalASTManager } = require('../../util/global-registry') const { md5 } = require('../../util/hash-util') +const { handleException } = require('../analyzer/common/exception-handler') const logger = require('../../util/logger')(__filename) // 语言解析器配置接口 @@ -31,6 +33,7 @@ const parsers: Record) => a js: null, python: null, golang: null, + php: null, } /** @@ -80,6 +83,12 @@ function getParser(language: string): ((code: string, options: Record) => PhpParser.parseSingleFile(c, opts) + parsers.php = parser + break + } default: throw new Error(`Unsupported language: ${language}`) } @@ -124,6 +133,38 @@ function hasValidNodeHash(ast: any, expectedSourcefile: string): boolean { return actualSourcefile === expectedSourcefile } +/** + * 遍历 AST 树，将已有 nodehash 的节点注册到 astManager（不重新计算 hash） + * 用于 Worker 子进程返回的 AST：hash 已在子进程计算，但未注册到主进程 astManager + */ +function registerExistingHashes(obj: any, astManager: any, visited?: Set): void { + if (!obj || typeof obj !== 'object') return + if (!visited) visited = new Set() + if (visited.has(obj)) return + visited.add(obj) + + if (obj._meta?.nodehash) { + astManager.register(obj) + } + + for (const key in obj) { + if (key === 'parent') continue + if (key === '_meta') { + if (Array.isArray(obj._meta?.annotations) && obj._meta.annotations.length > 0) { + for (const ann of obj._meta.annotations) registerExistingHashes(ann, astManager, visited) + } + if (Array.isArray(obj._meta?.decorators) && obj._meta.decorators.length > 0) { + for (const dec of obj._meta.decorators) registerExistingHashes(dec, astManager, visited) + } + continue + } + if (!Object.prototype.hasOwnProperty.call(obj, key)) continue + const subObj = obj[key] + if (!subObj || typeof subObj !== 'object') continue + registerExistingHashes(subObj, astManager, visited) + } +} + /** * AST 后处理：设置 sourcefile、添加 parent 指针、添加节点哈希 * @@ -151,20 +192,36 @@ function processAst( const fname = code != null ? SourceLine.storeCode(options?.sourcefile, code) : options?.sourcefile || '' if (shouldSetSourcefile) { - // annotateAST 会调用 adjustASTNode，为所有节点添加 parent 指针 - AstUtil.annotateAST(ast, options ? { sourcefile: fname } : null) - if (!ast.loc) ast.loc = {} - ast.loc.sourcefile = fname + try { + // annotateAST 会调用 adjustASTNode，为所有节点添加 parent 指针 + AstUtil.annotateAST(ast, options ? { sourcefile: fname } : null) + if (!ast.loc) ast.loc = {} + ast.loc.sourcefile = fname + } catch (e) { + handleException(e, `[processAst] annotateAST 失败: ${fname}`, `[processAst] annotateAST 失败: ${fname}`) + } } else { - // 即使不设置 sourcefile，也会添加 parent 指针 - AstUtil.annotateAST(ast, { skipSourcefile: true }) + try { + // 即使不设置 sourcefile，也会添加 parent 指针 + AstUtil.annotateAST(ast, { skipSourcefile: true }) + } catch (e) { + handleException(e, `[processAst] annotateAST 失败: ${fname}`, `[processAst] annotateAST 失败: ${fname}`) + } } - if (skipHashIfExists && hasValidNodeHash(ast, fname)) { - // hash 已存在且有效（sourcefile 匹配），跳过重新计算 - // 这样可以避免对缓存加载的 AST 重复计算 hash，显著提升性能 - } else { - addNodeHash(ast) + try { + if (skipHashIfExists && hasValidNodeHash(ast, fname)) { + // hash 已存在且有效，跳过重新计算，但补注册到 astManager + // Worker 子进程计算了 hash 但无法注册（子进程没有 astManager），主进程需要补注册 + const astManager = getGlobalASTManager() + if (astManager) { + registerExistingHashes(ast, astManager) + } + } else { + addNodeHash(ast) + } + } catch (e) { + handleException(e, `[processAst] addNodeHash 失败: ${fname}`, `[processAst] addNodeHash 失败: ${fname}`) } return ast @@ -438,8 +495,12 @@ function processProjectAst( } for (const { ast, filename } of astList) { - const sourceCode = sourceCodeCache[filename] || null - processParsedAst(ast, sourceCode, { sourcefile: filename, ...options }, config) + try { + const sourceCode = sourceCodeCache[filename] || null + processParsedAst(ast, sourceCode, { sourcefile: filename, ...options }, config) + } catch (e) { + handleException(e, `[processProjectAst] 文件后处理失败: ${filename}`, `[processProjectAst] 文件后处理失败: ${filename}`) + } } } diff --git a/src/engine/parser/parser-worker.ts b/src/engine/parser/parser-worker.ts index f8857919..335debb1 100644 --- a/src/engine/parser/parser-worker.ts +++ b/src/engine/parser/parser-worker.ts @@ -49,11 +49,24 @@ function deleteParent(node: any, visited = new Set()): void { /** * 处理解析任务（完整 parse + processAst，发送前删掉 parent 避免循环引用） */ +// PHP parser 需要异步初始化 tree-sitter WASM +let phpInitialized = false +async function ensurePhpParserReady(): Promise { + if (phpInitialized) return + const PhpParser = require('./php/php-ast-builder') + await PhpParser.ensureInitialized() + phpInitialized = true +} + async function processParseTask(task: ParseTask): Promise<{ filepath: string; ast: any; error?: string }> { if (task.config.maindirPrefix !== undefined) { config.maindirPrefix = task.config.maindirPrefix } try { + // PHP 需要先异步初始化 tree-sitter WASM + if (task.language === 'php') { + await ensurePhpParserReady() + } const result = parseFileCore(task.filepath, task.content, task.language, task.options, task.config) deleteParent(result.ast) return result diff --git a/src/engine/parser/parser.ts b/src/engine/parser/parser.ts index 9ffa19c9..03e81eda 100644 --- a/src/engine/parser/parser.ts +++ b/src/engine/parser/parser.ts @@ -689,6 +689,25 @@ class BaseParser { }, needsSourcefile: false, }) + + // 注册 PHP 解析器 + this.registry.register({ + language: 'php', + unit: 'file', + supportsIncremental: false, + parseAsFiles: true, + filePatterns: ['**/*.php'], + parseSingleFile: (code, options) => { + const PhpParser = require('./php/php-ast-builder') + return PhpParser.parseSingleFile(code, options) + }, + parseProject: async (rootDir, options) => { + const PhpParser = require('./php/php-ast-builder') + await PhpParser.ensureInitialized() + return null + }, + needsSourcefile: true, + }) } /** @@ -892,6 +911,11 @@ class BaseParser { const language = options.language! const enableIncremental = this.shouldEnableIncremental(language) + // parseAsFiles 模式下，先调用 config.parseProject 做语言特定的初始化（如 PHP tree-sitter WASM 加载） + if (config.parseProject) { + await config.parseProject(rootDir, options) + } + performanceTracker.record('preProcess.parseCode.loadFiles').start() // 1. 先获取文件列表（使用 globby，只获取路径，不读取内容） const filePaths = globby.sync(config.filePatterns, { cwd: rootDir }) diff --git a/src/engine/parser/php/php-ast-builder.ts b/src/engine/parser/php/php-ast-builder.ts new file mode 100644 index 00000000..155c359b --- /dev/null +++ b/src/engine/parser/php/php-ast-builder.ts @@ -0,0 +1,51 @@ +/* eslint-disable @typescript-eslint/no-require-imports */ +const { Parser: PhpUastParser } = require('@ant-yasa/uast-parser-php') + +let phpParser: InstanceType | null = null +let initPromise: Promise | null = null + +/** + * 确保 PHP parser 已异步初始化（加载 tree-sitter WASM） + * 多次调用安全，只初始化一次 + */ +async function ensureInitialized(): Promise { + if (!phpParser) { + phpParser = new PhpUastParser() + initPromise = phpParser.init() + } + if (initPromise) { + await initPromise + initPromise = null + } +} + +/** + * 解析单个 PHP 文件（同步接口） + * 调用前必须已完成 ensureInitialized() + * @param code - PHP 源代码 + * @param options - 解析选项（包含 sourcefile） + * @returns UAST 节点 + */ +function parseSingleFile(code: string, options?: Record): unknown { + if (!phpParser || initPromise) { + throw new Error('PHP parser 未初始化，请先调用 ensureInitialized()') + } + return phpParser.parse(code, options || {}) +} + +/** + * 项目解析接口（由 parser.ts 统一处理文件级解析） + * @param _rootDir - 项目根目录（未使用） + * @param _options - 解析选项（未使用） + * @returns null，由 parser.ts 逐文件调用 parseSingleFile + */ +// eslint-disable-next-line @typescript-eslint/no-unused-vars +async function parseProject(_rootDir: string, _options?: Record): Promise { + return null +} + +module.exports = { + ensureInitialized, + parseSingleFile, + parseProject, +} diff --git a/src/engine/parser/python/python-ast-builder.ts b/src/engine/parser/python/python-ast-builder.ts index fe481448..34b5a4b1 100644 --- a/src/engine/parser/python/python-ast-builder.ts +++ b/src/engine/parser/python/python-ast-builder.ts @@ -27,12 +27,7 @@ let uastFilePath = './uast' function buildUASTPython(rootDir: string, options?: BuildOptions): any { options = options || {} if (options.language && options.language !== 'python') { - handleException( - new Error(`Python AST Builder received wrong language type: ${options.language}`), - `Error: Python AST Builder received wrong language type: ${options.language}`, - `Error: Python AST Builder received wrong language type: ${options.language}` - ) - process.exit(1) + throw new Error(`Python AST Builder received wrong language type: ${options.language}`) } let isSingle = '' @@ -53,13 +48,7 @@ function buildUASTPython(rootDir: string, options?: BuildOptions): any { // if uast4pyPath does not exist, exit with error if (!uast4pyPath || !fs.existsSync(uast4pyPath)) { - handleException( - null, - // eslint-disable-next-line sonarjs/no-duplicate-string - `uast4py not found. Please set --uastSDKPath to the binary or deps directory, or install it under deps/uast4py/uast4py`, - `uast4py not found. Please set --uastSDKPath to the binary or deps directory, or install it under deps/uast4py/uast4py` - ) - process.exit(0) + throw new Error('uast4py binary not found, please check uastSDKPath configuration') } if (options.ASTFileOutput) { diff --git a/src/interface/starter.ts b/src/interface/starter.ts index 9b5bc45b..714eb3a2 100644 --- a/src/interface/starter.ts +++ b/src/interface/starter.ts @@ -1,6 +1,8 @@ /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, import/no-commonjs, @typescript-eslint/no-use-before-define */ +import v8 from 'v8' import { yasaLog } from "../util/format-util" +import { printMemorial } from '../util/memorial' const fs = require('fs-extra') const path = require('path') @@ -12,7 +14,7 @@ const Parser = require('../engine/parser/parser') const Stat = require('../util/statistics') const logger = require('../util/logger')(__filename) const FileUtil = require('../util/file-util') -const { ErrorCode, Errors } = require('../util/error-code') +const { ErrorCode, Errors, setExitCode } = require('../util/error-code') const FrameworkUtil = require('../util/framework-util') const { handleException } = require('../engine/analyzer/common/exception-handler') const OutputStrategyAutoRegister = require('../engine/analyzer/common/output-strategy-auto-register') @@ -40,9 +42,14 @@ async function execute(dir: any, args: any[] = [], printf?: any) { if (analyzer) { const processingDir = Config.maindir const exitCode = await executeAnalyzer(analyzer, processingDir) - process.exitCode = exitCode + setExitCode(exitCode) if (exitCode === 0) { - result = await outputAnalyzerResult(analyzer, printf) + try { + result = await outputAnalyzerResult(analyzer, printf) + } catch (e: any) { + handleException(e, 'Error occurred in outputAnalyzerResult', 'Error occurred in outputAnalyzerResult') + setExitCode(ErrorCode.fail_to_generate_report) + } } } @@ -101,6 +108,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { if (dir) { sourcePath = dir } + // 标记初始化是否遇到致命错误 + let initError = false // 标记是否显式设置了 --intermediate-dir let intermediateDirExplicitlySet = false // 标记是否显式设置了 --context-environment-dir @@ -116,7 +125,9 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { try { if (!fs.existsSync(d)) { handleException(null, `Error !! no such file or directory: ${d}`, `Error !! no such file or directory: ${d}`) - process.exit(1) + initError = true + setExitCode(ErrorCode.config_error) + return } const stats = fs.statSync(d) if (stats.isFile()) { @@ -129,18 +140,21 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { 'ERROR: an error occurred while reading source path', 'ERROR: an error occurred while reading source path' ) - process.exit(1) + initError = true + setExitCode(ErrorCode.config_error) } }) .option('--language ', '指定语言（支持: javascript/typescript/golang/python/java）', (lang: any) => { - const supported = ['javascript', 'typescript', 'js', 'ts', 'go', 'golang', 'python', 'java'] + const supported = ['javascript', 'typescript', 'js', 'ts', 'go', 'golang', 'python', 'java', 'php'] if (!supported.includes(lang)) { handleException( null, - 'Unknown language!! Only support javascript/typescript/golang/python/java', - 'Unknown language!! Only support javascript/typescript/golang/python/java' + 'Unknown language!! Only support javascript/typescript/golang/python/java/php', + 'Unknown language!! Only support javascript/typescript/golang/python/java/php' ) - process.exit(0) + initError = true + setExitCode(ErrorCode.config_error) + return } if (['typescript', 'ts', 'js', 'javascript'].includes(lang)) { lang = 'javascript' @@ -205,6 +219,9 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { Config.checkerIds = Array.isArray(Config.checkerIds) ? Config.checkerIds : [Config.checkerIds] Config.checkerIds.push('callgraph') }) + .option('--dumpEntrypoint', '输出入口点信息到 entrypoints.json', () => { + Config.dumpEntrypoint = true + }) .option('--source ', '指定source位置（QL专用）', (locations: any) => { if (!Config.FlowConfig) { Config.FlowConfig = {} @@ -285,7 +302,9 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { 'ERROR: --workerCount must be a non-negative integer', 'ERROR: --workerCount must be a non-negative integer' ) - process.exit(1) + initError = true + setExitCode(ErrorCode.config_error) + return } Config.workerCount = workerCount }) @@ -336,7 +355,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { 'ERROR: an error occurred while reading path', 'ERROR: an error occurred while reading path' ) - process.exit(1) + initError = true + setExitCode(ErrorCode.config_error) } } } @@ -353,9 +373,23 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { program.version(YASA_VERSION) + // echo：与 --version 同型——commander 解析到此选项立即打印并退出，不进入 analyzer + program.option('--echo', '致曾同行者', () => { + printMemorial() + process.exit(0) + }) + // 解析命令行参数 program.parse(args, { from: 'user' }) + // 启动诊断日志：放在 parse 之后，避免 --version / --echo 等立即退出选项混入噪音 + logger.info(`version: ${YASA_VERSION}`) + logger.info(`v8 heap_size_limit: ${v8.getHeapStatistics().heap_size_limit / 1024 / 1024}`, 'MB') + logger.info(`main file:${require.main?.filename}`) + + // commander 回调中遇到致命错误，直接返回 + if (initError) return null + // 检查如果启用了增量分析，但 --intermediate-dir 未设置或为空，则禁用增量分析 if ( Config.incremental !== false && @@ -416,12 +450,14 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { logger.info( 'Unknown command or unknown language!! Note the command using -- , and language support javascript/typescript/golang/python/java.' ) - process.exit(0) + setExitCode(ErrorCode.config_error) + return null } } } else { handleException(null, 'There is no sourcePath specified to analyze', 'There is no sourcePath specified to analyze') - process.exit(0) + setExitCode(ErrorCode.config_error) + return null } if (reportPath && reportPath !== '') { @@ -461,7 +497,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { if (Config.dumpAST) { if (!Config.single) { Errors.ParseError('Only support dump AST for single file, but given a dir') - process.exit(0) + setExitCode(ErrorCode.config_error) + return null } // read and parse the source file(s) const apps = loadSource(Config.maindir) @@ -477,7 +514,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { } else { await dumpAST(apps, logger.info.bind(logger)) } - process.exit(0) + setExitCode(ErrorCode.normal) + return null } // dump all AST @@ -492,10 +530,12 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { await Parser.dumpAllAST(Config.maindir, Config.reportDir, Config) logger.info('parseDirectory UAST success!') - process.exit(0) + setExitCode(ErrorCode.normal) + return null } catch (e: any) { handleException(e, 'Error occurred in dumpAllAST!!!!', `Error occurred in dumpAllAST!!!!${e}`) - process.exit(1) + setExitCode(ErrorCode.engine_failure) + return null } } @@ -512,6 +552,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { const PythonAnalyzer = require('../engine/analyzer/python/common/python-analyzer') + const PhpAnalyzer = require('../engine/analyzer/php/common/php-analyzer') + const analyzerEnum = { EggAnalyzer, JavaScriptAnalyzer, @@ -519,6 +561,7 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { GoAnalyzer, SpringAnalyzer, PythonAnalyzer, + PhpAnalyzer, } const analyzerLanguage = { EggAnalyzer: 'javascript', @@ -527,6 +570,7 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { SpringAnalyzer: 'java', GoAnalyzer: 'golang', PythonAnalyzer: 'python', + PhpAnalyzer: 'php', } let Analyzer: any @@ -536,8 +580,8 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { if (!Analyzer || Analyzer === '') { handleException( null, - 'analyzer set failed,now YASA supported EggAnalyzer|JavaScriptAnalyzer|JavaAnalyzer|SpringAnalyzer|GoAnalyzer|PythonAnalyzer', - 'analyzer set failed,now YASA supported EggAnalyzer|JavaScriptAnalyzer|JavaAnalyzer|SpringAnalyzer|GoAnalyzer|PythonAnalyzer' + 'analyzer set failed,now YASA supported EggAnalyzer|JavaScriptAnalyzer|JavaAnalyzer|SpringAnalyzer|GoAnalyzer|PythonAnalyzer|PhpAnalyzer', + 'analyzer set failed,now YASA supported EggAnalyzer|JavaScriptAnalyzer|JavaAnalyzer|SpringAnalyzer|GoAnalyzer|PythonAnalyzer|PhpAnalyzer' ) return } @@ -562,6 +606,9 @@ async function initAnalyzer(dir: any, args: any[] = [], printf?: any) { case 'python': f = 'PythonAnalyzer' break + case 'php': + f = 'PhpAnalyzer' + break default: handleException(null, 'default analyzer set failed', 'default analyzer set failed') return @@ -588,15 +635,15 @@ async function executeAnalyzer(analyzer: any, processingDir: any): Promise 0 && Array.isArray(state.argumentTypes)) { + } else if (val.vtype === 'fclos' && (val.overloaded?.length ?? 0) > 0 && Array.isArray(state.argumentTypes)) { funcDef = this.findMatchedFuncDef(val, state.argumentTypes) const funcReturnTypeArray = this.resolveInstruction(analyzer, scope, funcDef.returnType, state) for (const funcReturnType of funcReturnTypeArray) { diff --git a/src/resolver/go/go-type-related-info-resolver.ts b/src/resolver/go/go-type-related-info-resolver.ts index 2d62b987..c83fd6f2 100644 --- a/src/resolver/go/go-type-related-info-resolver.ts +++ b/src/resolver/go/go-type-related-info-resolver.ts @@ -2,17 +2,99 @@ import TypeRelatedInfoResolver from '../common/type-related-info-resolver' import type { ClassHierarchy } from '../common/value/class-hierarchy' /** - * 多态性还未实现，暂不建议使用 + * Go 结构化类型匹配：通过 duck typing 判断 struct 是否实现 interface */ export default class GoTypeRelatedInfoResolver extends TypeRelatedInfoResolver { /** - * find class hierarchy - * @param analyzer - * @param state - * @returns {Map} + * 构建 ClassHierarchy，基于 Go 的结构化类型匹配（duck typing） + * interface 方法从 AST 提取（因为 interface 方法签名无 body，不会存入 scope.value） + * struct 方法从 scope.value 用 for...in 遍历（Proxy 支持 for...in 但不支持 Object.keys） */ - override findClassHierarchy(analyzer: any, state: any): Map { - // TODO - return new Map() + override findClassHierarchy(analyzer: any, _state: any): Map { + if (!analyzer.classMap || analyzer.classMap.size === 0) { + return new Map() + } + + const result = new Map() + + // 第一步：为每个 class/interface 构建 ClassHierarchy 节点 + for (const [logicalQid, uuid] of analyzer.classMap as Map) { + const classVal = analyzer.symbolTable.get(uuid) + if (!classVal) continue + + const node: ClassHierarchy = { + typeDeclaration: classVal.isInterface ? 'interface' : 'class', + type: classVal.logicalQid || classVal.qid, + value: classVal, + extends: [], + extendedBy: [], + implements: [], + implementedBy: [], + } + result.set(logicalQid, node) + } + + // 第二步：收集每个 interface 的方法名集合（从 AST 提取，跳过空接口） + const interfaceMethods = new Map>() + for (const [logicalQid, node] of result) { + if (node.typeDeclaration !== 'interface') continue + + const methods = new Set() + const classVal = node.value + // interface 方法签名无 body，processFunctionDefinition 不会 createFuncScope + // 因此必须从 AST 的 ClassDefinition body 中提取方法名 + const astCdef = classVal.ast?.cdef + const astNode = classVal.ast?.node + const src = astCdef || astNode + // Go UAST 的 ClassDefinition body 直接是数组（不是 {type: 'Block', body: [...]}） + const bodyNodes = Array.isArray(src?.body) ? src.body + : Array.isArray(src?.body?.body) ? src.body.body + : [] + for (const bodyNode of bodyNodes) { + // Go interface body：方法签名是 FuncType，普通 interface 中也可能是 FunctionDefinition + const name = bodyNode.id?.name + if (name && (bodyNode.type === 'FunctionDefinition' || bodyNode.type === 'FuncType')) { + methods.add(name) + } + } + + // 跳过空接口（interface{}） + if (methods.size === 0) continue + interfaceMethods.set(logicalQid, methods) + } + + // 第三步：对每个 struct，检查是否满足某个 interface 的全部方法 + for (const [_structQid, structNode] of result) { + if (structNode.typeDeclaration !== 'class') continue + + // 收集 struct 的方法名集合 + // for...in 能遍历 EntityValue Proxy 的成员，Object.keys() 不能 + const structMethods = new Set() + const classVal = structNode.value + if (classVal.value) { + for (const key in classVal.value) { + const member = classVal.value[key] + if (member?.vtype === 'fclos') { + structMethods.add(key) + } + } + } + + // 与每个 interface 进行方法匹配 + for (const [ifaceQid, ifaceMethods] of interfaceMethods) { + if (structMethods.size < ifaceMethods.size) continue + + const implementsAll = [...ifaceMethods].every(m => structMethods.has(m)) + if (!implementsAll) continue + + const ifaceNode = result.get(ifaceQid) + if (!ifaceNode) continue + + // 建立双向关系 + structNode.implements.push(ifaceNode) + ifaceNode.implementedBy.push(structNode) + } + } + return result } } diff --git a/src/util/ast-util.ts b/src/util/ast-util.ts index d34ff4c6..d580cda1 100644 --- a/src/util/ast-util.ts +++ b/src/util/ast-util.ts @@ -218,6 +218,10 @@ function addNodeHashInternal(obj: any, visited: WeakSet): void { if (obj.type) { const { loc } = obj let content = getRawCode(obj) + // 防御：确保 content 为 string（getRawCode 可能返回非 string 值） + if (typeof content !== 'string') { + content = String(content ?? '') + } // 非常重要的性能优化，尽量保留，对于特殊程序，如（content超过4000字符），可能快 10 倍 const MAX_CONTENT_LENGTH = 128 @@ -844,7 +848,8 @@ function prettyPrint(node: any): string { return `${prettyPrint(node.label)}: {${prettyPrint(node.body)}` } case 'Literal': { - return node.value + // Literal 值可能是 number/boolean，必须转为 string + return String(node.value) } case 'MemberAccess': { return `${prettyPrint(node.object)}.${prettyPrint(node.property)}` diff --git a/src/util/clone-util.ts b/src/util/clone-util.ts index e178f8d1..6bd6bd3e 100644 --- a/src/util/clone-util.ts +++ b/src/util/clone-util.ts @@ -2,6 +2,8 @@ const _ = require('lodash') import { RAW_TARGET } from '../engine/analyzer/common/value/symbols' let _instanceCounter = 0 +// 追踪同一 AST 位置创建的实例数量，用于去重：防止 func 多次调用时实例 QID 碰撞 +const _sigUsageCount: Map = new Map() import { ObjectValue } from '../engine/analyzer/common/value/object' import { SymbolValue } from '../engine/analyzer/common/value/symbolic' import { PackageValue } from '../engine/analyzer/common/value/package' @@ -130,7 +132,7 @@ function buildNewValueInstance( node?.loc?.end?.column ) { const filename = node.loc.sourcefile.split('/').pop() - sig = `${filename.substring(0, filename.lastIndexOf('.') > 0 ? filename.lastIndexOf('.') : filename.length)}_${node.loc?.start?.line}_${node.loc?.start?.column}_${node.loc?.end?.line}_${node.loc?.end?.column}` + sig = `${filename.substring(0, filename.lastIndexOf('.') > 0 ? filename.lastIndexOf('.') : filename.length)}_${node.loc?.start?.line}_${node.loc?.start?.column}_${node.loc?.end?.line}_${node.loc?.end?.column}_${++_instanceCounter}` } else if ( node?.callee?.loc && node?.callee?.loc?.sourcefile && @@ -140,12 +142,18 @@ function buildNewValueInstance( node?.callee?.loc?.end?.column ) { const filename = node.callee.loc.sourcefile.split('/').pop() - sig = `${filename.substring(0, filename.lastIndexOf('.') > 0 ? filename.lastIndexOf('.') : filename.length)}_${node.callee.loc?.start?.line}_${node.callee.loc?.start?.column}_${node.callee.loc?.end?.line}_${node.callee.loc?.end?.column}` + sig = `${filename.substring(0, filename.lastIndexOf('.') > 0 ? filename.lastIndexOf('.') : filename.length)}_${node.callee.loc?.start?.line}_${node.callee.loc?.start?.column}_${node.callee.loc?.end?.line}_${node.callee.loc?.end?.column}_${++_instanceCounter}` } else { sig = `` } - opts._sid = `${originalObj.sid}` - opts._qid = `${originalObj.qid}${qidSuffix}` + // 同一 (originalObj.qid, sig) 组合被多次使用时，追加计数器以避免 UUID 碰撞 + // 场景：同一函数被多次调用，每次在相同 AST 位置创建不同实例（如 Regist 被调用 21 次） + const dedupKey = `${originalObj.qid}|${sig}` + const dedupCount = (_sigUsageCount.get(dedupKey) ?? 0) + 1 + _sigUsageCount.set(dedupKey, dedupCount) + const dedupSuffix = dedupCount > 1 ? `_x${dedupCount}` : '' + opts._sid = `${originalObj.sid}` + opts._qid = `${originalObj.qid}${qidSuffix}` opts._skipRegister = false const CtorClass = (!forceVtype || forceVtype === 'object') ? ObjectValue : (INSTANCE_CTOR_MAP[originalObj.constructor?.name] || ObjectValue) const obj = new CtorClass(opts) diff --git a/src/util/constant.ts b/src/util/constant.ts index e8baef52..c8fefe2f 100644 --- a/src/util/constant.ts +++ b/src/util/constant.ts @@ -7,7 +7,7 @@ export const ENGIN_START_FILE_BEGIN = 'fileBegin' export const YASA_DEFAULT = 'YASADefault' // 基础版本号 -const BASE_VERSION = '0.2.19-inner-dev' +const BASE_VERSION = '0.2.22-inner' /** * 尝试读取构建时生成的版本信息文件 diff --git a/src/util/error-code.ts b/src/util/error-code.ts index 0282e769..0c02378b 100644 --- a/src/util/error-code.ts +++ b/src/util/error-code.ts @@ -13,6 +13,7 @@ type ErrorConstructor = (message: string, headMsg?: string, opts?: { no_throw?: const ErrorCode = { normal: 0, + config_error: 10, no_valid_source_file: 11, fail_to_parse: 12, @@ -25,6 +26,8 @@ const ErrorCode = { toString(code: number): string { switch (code) { + case 10: + return 'configuration or parameter error' case 11: return 'no valid source file is found within the given directory' case 12: @@ -215,4 +218,12 @@ function errorTolerance(err: Error): boolean { return !(builtin_error_report || base_error_report) } -export { Errors, ErrorCode, BaseError } +/** + * 安全设置退出码：非零退出码不会被零覆盖 + */ +function setExitCode(code: number): void { + if (code === 0 && process.exitCode && process.exitCode !== 0) return + process.exitCode = code +} + +export { Errors, ErrorCode, BaseError, setExitCode } diff --git a/src/util/file-util.ts b/src/util/file-util.ts index e637634c..e6d5bf60 100644 --- a/src/util/file-util.ts +++ b/src/util/file-util.ts @@ -198,18 +198,13 @@ function loadAllFileTextGlobby(srcFilter: string[], cwd: string): FileContent[] */ function loadJSONfile(filename: string): any { if (!fs.existsSync(filename)) { - handleException( - null, - `loading JSON file error: ${filename}. File does not exist`, - `loading JSON file error: ${filename}. File does not exist` - ) - process.exit(1) + throw new Error(`JSON file not found: ${filename}`) } try { return jsonfile.readFileSync(filename) } catch (e) { handleException(e, `jsonfile parse error:${filename}`, `jsonfile parse error:${filename}`) - process.exit(1) + throw new Error(`Failed to parse JSON file: ${filename}`) } } diff --git a/src/util/framework-util.ts b/src/util/framework-util.ts index 088603fb..a97b76c9 100644 --- a/src/util/framework-util.ts +++ b/src/util/framework-util.ts @@ -21,16 +21,21 @@ function eggSanityCheck(appEntryDir: string): boolean { return false } + // 传统 egg 目录结构：app/ + config/ const appDir = path.join(appEntryDir, 'app') const configDir = path.join(appEntryDir, 'config') - if (!fs.existsSync(appDir)) { - return false + if (fs.existsSync(appDir) && fs.existsSync(configDir)) { + return true } - if (!fs.existsSync(configDir)) { - return false + + // tegg 新目录结构：src/ + module.yml + const srcDir = path.join(appEntryDir, 'src') + const moduleYml = path.join(appEntryDir, 'module.yml') + if (fs.existsSync(srcDir) && fs.existsSync(moduleYml)) { + return true } - return true + return false } /** diff --git a/src/util/loader.ts b/src/util/loader.ts index ae26e58c..a1ea399f 100644 --- a/src/util/loader.ts +++ b/src/util/loader.ts @@ -46,12 +46,7 @@ function defaultCamelize(filepath: string, caseStyle: 'lower' | 'upper' | 'camel // }).join(''); // } if (!/^[a-z0-9][a-z0-9._-]*$/i.test(property)) { - handleException( - new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`), - `Error: ${property} is not match 'a-z0-9_-' in ${filepath}`, - `Error: ${property} is not match 'a-z0-9_-' in ${filepath}` - ) - process.exit(1) + throw new Error(`File path does not match naming convention: ${property} in ${filepath}`) } // use default camelize, will capitalize the first letter diff --git a/src/util/memorial.ts b/src/util/memorial.ts new file mode 100644 index 00000000..ef9bfa2d --- /dev/null +++ b/src/util/memorial.ts @@ -0,0 +1,145 @@ +/* + * 在高远的黑色穹顶下，他们留下的光使圣巢不曾黯淡。 + * + * 此文件为 YASA 引擎曾经的深度参与者所立。 + * 他们从蚂蚁启程去了下个地方， + * 但项目今日的形状，与他们密不可分。 + * + * 命令 `yasa --echo` 可拜访此处。 + * 若有未来的同伴亦自此启程，请将其碑续刻于 STELAE 之末。 + */ + +interface Stele { + readonly name: string + readonly departureDate: string + readonly body: readonly string[] +} + +const EPIGRAPH: readonly string[] = ['在高远的黑色穹顶下，', '他们留下的光使圣巢不曾黯淡。'] + +const STELAE: readonly Stele[] = [ + { + name: '非牛', + departureDate: '二〇二四年七月十一日', + body: [ + '前路迷叠，皆以从容坦然走过，', + '旁人倦怠，皆以温朗重拾明光。', + '圣巢记下他的开拓行迹，', + '携一身意气，走向天际破晓。', + ], + }, + { + name: '季亭', + departureDate: '二〇二六年四月二十七日', + body: [ + '细处隐瑕，皆以静心逐一洞悉，', + '诸事失序，皆以严谨慢慢规整。', + '圣巢留藏她的治学痕迹，', + '怀一份沉敛，静守此间安隅。', + ], + }, +] + +const BOX_INNER_WIDTH = 54 +const BOX_CONTENT_INDENT = 6 +const OUTER_INDENT = ' ' + +const RULE = `${OUTER_INDENT}${'─'.repeat(BOX_INNER_WIDTH)}` +const INDENT_HEADING = ' ' +const INDENT_BODY = ' ' +const INDENT_SIGN = ' ' + +// 按显示宽度计算：CJK 字符占 2 列，其余 1 列；用于总题 box 的右侧对齐 +/** + * + * @param s + */ +function visualWidth(s: string): number { + let w = 0 + for (const c of s) { + const cp = c.codePointAt(0) ?? 0 + const isWide = + (cp >= 0x1100 && cp <= 0x115f) || + (cp >= 0x2e80 && cp <= 0x303e) || + (cp >= 0x3041 && cp <= 0x33ff) || + (cp >= 0x3400 && cp <= 0x4dbf) || + (cp >= 0x4e00 && cp <= 0x9fff) || + (cp >= 0xa000 && cp <= 0xa4cf) || + (cp >= 0xac00 && cp <= 0xd7a3) || + (cp >= 0xf900 && cp <= 0xfaff) || + (cp >= 0xfe30 && cp <= 0xfe4f) || + (cp >= 0xff00 && cp <= 0xff60) || + (cp >= 0xffe0 && cp <= 0xffe6) + w += isWide ? 2 : 1 + } + return w +} + +/** + * + * @param s + * @param targetWidth + */ +function padToWidth(s: string, targetWidth: number): string { + const gap = targetWidth - visualWidth(s) + return gap > 0 ? s + ' '.repeat(gap) : s +} + +/** + * + * @param out + */ +function writeBlankLine(out: NodeJS.WriteStream): void { + out.write('\n') +} + +/** + * + * @param out + */ +function writeEpigraph(out: NodeJS.WriteStream): void { + const top = `${OUTER_INDENT}╔${'═'.repeat(BOX_INNER_WIDTH)}╗` + const bot = `${OUTER_INDENT}╚${'═'.repeat(BOX_INNER_WIDTH)}╝` + const emptyLine = `${OUTER_INDENT}║${' '.repeat(BOX_INNER_WIDTH)}║` + + out.write(`${top}\n`) + out.write(`${emptyLine}\n`) + for (const line of EPIGRAPH) { + const content = ' '.repeat(BOX_CONTENT_INDENT) + line + out.write(`${OUTER_INDENT}║${padToWidth(content, BOX_INNER_WIDTH)}║\n`) + } + out.write(`${emptyLine}\n`) + out.write(`${bot}\n`) +} + +/** + * + * @param out + * @param stele + */ +function writeStele(out: NodeJS.WriteStream, stele: Stele): void { + writeBlankLine(out) + writeBlankLine(out) + out.write(`${INDENT_HEADING}${stele.name}曾行经此处。\n`) + writeBlankLine(out) + for (const line of stele.body) { + out.write(`${INDENT_BODY}${line}\n`) + } + writeBlankLine(out) + out.write(`${INDENT_SIGN}启程之日：${stele.departureDate}。\n`) + writeBlankLine(out) + out.write(`${RULE}\n`) +} + +/** + * + */ +export function printMemorial(): void { + const out = process.stdout + writeBlankLine(out) + writeEpigraph(out) + for (const stele of STELAE) { + writeStele(out, stele) + } + writeBlankLine(out) +} diff --git a/src/util/performance-tracker.ts b/src/util/performance-tracker.ts index 7c5c7131..283aef1e 100644 --- a/src/util/performance-tracker.ts +++ b/src/util/performance-tracker.ts @@ -454,7 +454,7 @@ class PerformanceTracker { // 使用 AST 估算代码行数 for (const filename of filesToCount) { - const { ast } = analyzer.symbolTable.get(analyzer.fileManager[filename]) || {} + const ast = analyzer.fileManager[filename]?.astNode if (ast) { if (ast.loc?.end?.line) { totalLines += ast.loc.end.line diff --git a/src/util/qid-unify-util.ts b/src/util/qid-unify-util.ts index 7596089a..dbb6ae63 100644 --- a/src/util/qid-unify-util.ts +++ b/src/util/qid-unify-util.ts @@ -236,6 +236,14 @@ class QidUnifyUtil { static removeInstanceFromString(value: string): string { return new QidUnifyUtil(value).removeInstance().removeCopied().get() } + + /** + * 静态方法，去掉字符串中的圆括号及其内容 + * @param value 要处理的字符串 + */ + static removeParenthesesFromString(value: string): string { + return new QidUnifyUtil(value).removeParentheses().get() + } } module.exports = QidUnifyUtil diff --git a/test/callchain/expect/callchain-go-expect.json b/test/callchain/expect/callchain-go-expect.json index d1a7c472..2dfd793c 100644 --- a/test/callchain/expect/callchain-go-expect.json +++ b/test/callchain/expect/callchain-go-expect.json @@ -12,7 +12,7 @@ }, "sinkInfo": { "sinkRule": "Query", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Query(query)", "file": "/test_callchain.go", @@ -83,7 +83,7 @@ }, "sinkInfo": { "sinkRule": "Exec", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Exec(query)", "file": "/test_callchain.go", @@ -154,7 +154,7 @@ }, "sinkInfo": { "sinkRule": "exec.Command", - "sinkAttribute": "GoCommandInjection", + "sinkAttribute": ["GoCommandInjection"], "callSite": { "code": "\tcmd := exec.Command(\"sh\", \"-c\", command)", "file": "/test_callchain.go", @@ -225,7 +225,7 @@ }, "sinkInfo": { "sinkRule": "Query", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Query(query)", "file": "/test_callchain.go", @@ -296,7 +296,7 @@ }, "sinkInfo": { "sinkRule": "Exec", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Exec(query)", "file": "/test_callchain.go", @@ -367,7 +367,7 @@ }, "sinkInfo": { "sinkRule": "exec.Command", - "sinkAttribute": "GoCommandInjection", + "sinkAttribute": ["GoCommandInjection"], "callSite": { "code": "\tcmd := exec.Command(\"sh\", \"-c\", command)", "file": "/test_callchain.go", @@ -436,7 +436,7 @@ }, "sinkInfo": { "sinkRule": "Query", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Query(query)", "file": "/test_callchain.go", @@ -489,7 +489,7 @@ }, "sinkInfo": { "sinkRule": "Exec", - "sinkAttribute": "GoSQLInjection", + "sinkAttribute": ["GoSQLInjection"], "callSite": { "code": "\tdb.Exec(query)", "file": "/test_callchain.go", @@ -542,7 +542,7 @@ }, "sinkInfo": { "sinkRule": "exec.Command", - "sinkAttribute": "GoCommandInjection", + "sinkAttribute": ["GoCommandInjection"], "callSite": { "code": "\tcmd := exec.Command(\"sh\", \"-c\", command)", "file": "/test_callchain.go", diff --git a/test/callchain/expect/callchain-java-expect.json b/test/callchain/expect/callchain-java-expect.json index 37a6c991..ab8b11e9 100644 --- a/test/callchain/expect/callchain-java-expect.json +++ b/test/callchain/expect/callchain-java-expect.json @@ -12,7 +12,7 @@ }, "sinkInfo": { "sinkRule": "executeQuery", - "sinkAttribute": "JavaSQLInjection", + "sinkAttribute": ["JavaSQLInjection"], "callSite": { "code": " stmt.executeQuery(query);", "file": "/TestCallchain.java", @@ -67,7 +67,7 @@ }, "sinkInfo": { "sinkRule": "exec", - "sinkAttribute": "JavaCommandExec", + "sinkAttribute": ["JavaCommandExec"], "callSite": { "code": " Runtime.getRuntime().exec(command);", "file": "/TestCallchain.java", diff --git a/test/callchain/expect/callchain-js-expect.json b/test/callchain/expect/callchain-js-expect.json index 18e5e96e..1bf5558c 100644 --- a/test/callchain/expect/callchain-js-expect.json +++ b/test/callchain/expect/callchain-js-expect.json @@ -1,17 +1,19 @@ { "version": "1.0", - "totalFindings": 9, + "totalFindings": 6, "findings": [ { "entrypoint": { - "filePath": "YASADefault", - "functionName": "YASADefault", - "attribute": "YASADefault", - "funcReceiverType": "YASADefault" + "filePath": "/test_callchain.js", + "functionName": "testSqlInjection", + "attribute": "fullCallGraphMade", + "funcReceiverType": "" }, "sinkInfo": { "sinkRule": "connection.query", - "sinkAttribute": "JSSQLInjection", + "sinkAttribute": [ + "JSSQLInjection" + ], "callSite": { "code": " connection.query(query, function (error, results, fields) {", "file": "/test_callchain.js", @@ -58,178 +60,16 @@ }, { "entrypoint": { - "filePath": "YASADefault", - "functionName": "YASADefault", - "attribute": "YASADefault", - "funcReceiverType": "YASADefault" - }, - "sinkInfo": { - "sinkRule": "child_process.exec", - "sinkAttribute": "JSCommandExec", - "callSite": { - "code": " exec(command, (error, stdout, stderr) => {", - "file": "/test_callchain.js", - "line": 32, - "column": 5 - } - }, - "callstack": [ - { - "type": 0, - "nodeHash": "176a70c2f8672528cc8cdb9b08b3fed2", - "fullName": "/test_callchain.testCommandInjection", - "function": "testCommandInjection", - "file": "/test_callchain.js", - "line": 30, - "column": 1 - }, - { - "type": 1, - "nodeHash": "7f45db454226c3e3132def6605c7007a", - "fullName": "child_process.exec", - "function": "exec", - "file": "/test_callchain.js", - "line": 32, - "column": 5 - } - ], - "callsites": [ - { - "code": "testCommandInjection('ls -la');", - "nodeHash": "a79005a1148a94a1b66cf30f6d24aee3", - "file": "/test_callchain.js", - "line": 52, - "column": 1 - }, - { - "code": " exec(command, (error, stdout, stderr) => {\n if (error) {\n console.error(`exec ", - "nodeHash": "7f45db454226c3e3132def6605c7007a", - "file": "/test_callchain.js", - "line": 32, - "column": 5 - } - ] - }, - { - "entrypoint": { - "filePath": "YASADefault", - "functionName": "YASADefault", - "attribute": "YASADefault", - "funcReceiverType": "YASADefault" - }, - "sinkInfo": { - "sinkRule": "eval", - "sinkAttribute": "JSEvalInjection", - "callSite": { - "code": " eval(code);", - "file": "/test_callchain.js", - "line": 47, - "column": 5 - } - }, - "callstack": [ - { - "type": 0, - "nodeHash": "ba6b76b84719810d6d28ec51048f8162", - "fullName": "/test_callchain.testEvalInjection", - "function": "testEvalInjection", - "file": "/test_callchain.js", - "line": 45, - "column": 1 - }, - { - "type": 1, - "nodeHash": "8bf38db1a0288bc4c4ab1c7bc8cc280a", - "fullName": "/test_callchain.testEvalInjection.eval", - "function": "eval", - "file": "/test_callchain.js", - "line": 47, - "column": 5 - } - ], - "callsites": [ - { - "code": "testEvalInjection('console.log(\"test\")');", - "nodeHash": "4953778979b01df31240e67bc3980b63", - "file": "/test_callchain.js", - "line": 53, - "column": 1 - }, - { - "code": " eval(code);", - "nodeHash": "8bf38db1a0288bc4c4ab1c7bc8cc280a", - "file": "/test_callchain.js", - "line": 47, - "column": 5 - } - ] - }, - { - "entrypoint": { - "type": "functionCall", - "functionName": "testSqlInjection", "filePath": "/test_callchain.js", - "attribute": "fullCallGraphMade", - "funcReceiverType": "" - }, - "sinkInfo": { - "sinkRule": "connection.query", - "sinkAttribute": "JSSQLInjection", - "callSite": { - "code": " connection.query(query, function (error, results, fields) {", - "file": "/test_callchain.js", - "line": 19, - "column": 5 - } - }, - "callstack": [ - { - "type": 0, - "nodeHash": "bb4f27bcf467d15bc6c2637fa9544dd0", - "fullName": "/test_callchain.testSqlInjection", - "function": "testSqlInjection", - "file": "/test_callchain.js", - "line": 7, - "column": 1 - }, - { - "type": 1, - "nodeHash": "c0dcaa8aa340b4b76b204d21f7bdf1f2", - "fullName": "mysql.createConnection({host:localhost, user:root, password:password, database:test}).query", - "function": "query", - "file": "/test_callchain.js", - "line": 19, - "column": 5 - } - ], - "callsites": [ - { - "code": "function testSqlInjection(userInput) {\n const connection = mysql.createConnection({\n host:", - "nodeHash": "bb4f27bcf467d15bc6c2637fa9544dd0", - "file": "/test_callchain.js", - "line": 7, - "column": 1 - }, - { - "code": " connection.query(query, function (error, results, fields) {\n if (error) throw error;\n ", - "nodeHash": "c0dcaa8aa340b4b76b204d21f7bdf1f2", - "file": "/test_callchain.js", - "line": 19, - "column": 5 - } - ] - }, - { - "entrypoint": { - "type": "functionCall", "functionName": "testCommandInjection", - "filePath": "/test_callchain.js", "attribute": "fullCallGraphMade", "funcReceiverType": "" }, "sinkInfo": { "sinkRule": "child_process.exec", - "sinkAttribute": "JSCommandExec", + "sinkAttribute": [ + "JSCommandExec" + ], "callSite": { "code": " exec(command, (error, stdout, stderr) => {", "file": "/test_callchain.js", @@ -259,10 +99,10 @@ ], "callsites": [ { - "code": "function testCommandInjection(command) {\n // This should be detected as a sink match\n exec(com", - "nodeHash": "176a70c2f8672528cc8cdb9b08b3fed2", + "code": "testCommandInjection('ls -la');", + "nodeHash": "a79005a1148a94a1b66cf30f6d24aee3", "file": "/test_callchain.js", - "line": 30, + "line": 52, "column": 1 }, { @@ -276,15 +116,16 @@ }, { "entrypoint": { - "type": "functionCall", - "functionName": "testEvalInjection", "filePath": "/test_callchain.js", + "functionName": "testEvalInjection", "attribute": "fullCallGraphMade", "funcReceiverType": "" }, "sinkInfo": { "sinkRule": "eval", - "sinkAttribute": "JSEvalInjection", + "sinkAttribute": [ + "JSEvalInjection" + ], "callSite": { "code": " eval(code);", "file": "/test_callchain.js", @@ -314,10 +155,10 @@ ], "callsites": [ { - "code": "function testEvalInjection(code) {\n // This should be detected as a sink match\n eval(code);\n}", - "nodeHash": "ba6b76b84719810d6d28ec51048f8162", + "code": "testEvalInjection('console.log(\"test\")');", + "nodeHash": "4953778979b01df31240e67bc3980b63", "file": "/test_callchain.js", - "line": 45, + "line": 53, "column": 1 }, { @@ -338,7 +179,9 @@ }, "sinkInfo": { "sinkRule": "connection.query", - "sinkAttribute": "JSSQLInjection", + "sinkAttribute": [ + "JSSQLInjection" + ], "callSite": { "code": " connection.query(query, function (error, results, fields) {", "file": "/test_callchain.js", @@ -392,7 +235,9 @@ }, "sinkInfo": { "sinkRule": "child_process.exec", - "sinkAttribute": "JSCommandExec", + "sinkAttribute": [ + "JSCommandExec" + ], "callSite": { "code": " exec(command, (error, stdout, stderr) => {", "file": "/test_callchain.js", @@ -446,7 +291,9 @@ }, "sinkInfo": { "sinkRule": "eval", - "sinkAttribute": "JSEvalInjection", + "sinkAttribute": [ + "JSEvalInjection" + ], "callSite": { "code": " eval(code);", "file": "/test_callchain.js", diff --git a/test/callchain/expect/callchain-python-expect.json b/test/callchain/expect/callchain-python-expect.json index 9b29b238..08f675e4 100644 --- a/test/callchain/expect/callchain-python-expect.json +++ b/test/callchain/expect/callchain-python-expect.json @@ -11,7 +11,7 @@ }, "sinkInfo": { "sinkRule": "cursor.execute", - "sinkAttribute": "PythonSQLInjection", + "sinkAttribute": ["PythonSQLInjection"], "callSite": { "code": " cursor.execute(query)", "file": "/test_callchain.py", @@ -65,7 +65,7 @@ }, "sinkInfo": { "sinkRule": "subprocess.call", - "sinkAttribute": "PythonCommandExec", + "sinkAttribute": ["PythonCommandExec"], "callSite": { "code": " result = subprocess.call(command, shell=True)", "file": "/test_callchain.py", @@ -119,7 +119,7 @@ }, "sinkInfo": { "sinkRule": "os.system", - "sinkAttribute": "PythonCommandExec", + "sinkAttribute": ["PythonCommandExec"], "callSite": { "code": " os.system(command)", "file": "/test_callchain.py", @@ -173,7 +173,7 @@ }, "sinkInfo": { "sinkRule": "eval", - "sinkAttribute": "PythonEvalInjection", + "sinkAttribute": ["PythonEvalInjection"], "callSite": { "code": " eval(code)", "file": "/test_callchain.py", diff --git a/test/callchain/test-all-callchain.ts b/test/callchain/test-all-callchain.ts index 47d8de4e..ba8725e8 100644 --- a/test/callchain/test-all-callchain.ts +++ b/test/callchain/test-all-callchain.ts @@ -1,4 +1,7 @@ import * as path from 'path' +import * as fs from 'fs' +// @ts-ignore +import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' const { execute } = require('../../src/interface/starter') const logger = require('../../src/util/logger')(__filename) @@ -41,7 +44,7 @@ const tests: TestConfig[] = [ }, ] -async function runCallchainTest(config: TestConfig): Promise { +async function runCallchainTest(config: TestConfig): Promise { console.log(`\n${'='.repeat(60)}`) console.log(`Testing ${config.name} Callchain Checker`) console.log(`${'='.repeat(60)}`) @@ -49,14 +52,15 @@ async function runCallchainTest(config: TestConfig): Promise { console.log(`Rule config: ${config.ruleConfigFile}`) try { + const reportDir = path.join(config.testDir, 'report') const args = [ config.testDir, '--ruleConfigFile', config.ruleConfigFile, '--analyzer', config.analyzer, - '--reportDir', - path.join(config.testDir, 'report'), + '--report', + reportDir, '--entryPointMode', 'ONLY_CUSTOM', '--checkerPackIds', @@ -72,6 +76,19 @@ async function runCallchainTest(config: TestConfig): Promise { console.log(` - Callchain findings: ${result.callchain.length}`) } } + + // 计算 trace 准确率 + const sarifPath = path.join(reportDir, 'report.sarif') + if (fs.existsSync(sarifPath)) { + const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) + const stats = computeAccuracyFromSarif(sarifData) + const pct = stats.evaluableHops > 0 ? ((stats.accurateHops / stats.evaluableHops) * 100).toFixed(2) : 'N/A' + console.log( + ` Trace Accuracy: ${pct}% (${stats.accurateHops}/${stats.evaluableHops} hops, ${stats.totalFindings} findings)` + ) + return stats + } + return null } catch (error) { console.error(`\n✗ ${config.name} Callchain test failed:`, error) throw error @@ -83,12 +100,12 @@ async function runAllTests(): Promise { console.log('Running All Callchain Checker Tests') console.log('='.repeat(60)) - const results: Array<{ name: string; success: boolean; error?: any }> = [] + const results: Array<{ name: string; success: boolean; error?: any; accuracy?: AccuracyStats | null }> = [] for (const test of tests) { try { - await runCallchainTest(test) - results.push({ name: test.name, success: true }) + const accuracy = await runCallchainTest(test) + results.push({ name: test.name, success: true, accuracy }) } catch (error) { results.push({ name: test.name, success: false, error }) } @@ -111,6 +128,24 @@ async function runAllTests(): Promise { console.log(`\nTotal: ${results.length} | Passed: ${passedCount} | Failed: ${failedCount}`) + // 输出 trace 准确率汇总 + console.log('\n' + '='.repeat(60)) + console.log('Trace Accuracy Summary') + console.log('='.repeat(60)) + for (const result of results) { + if (result.accuracy) { + const pct = + result.accuracy.evaluableHops > 0 + ? ((result.accuracy.accurateHops / result.accuracy.evaluableHops) * 100).toFixed(2) + : 'N/A' + console.log( + `${result.name}: ${pct}% (${result.accuracy.accurateHops}/${result.accuracy.evaluableHops} hops, ${result.accuracy.totalFindings} findings)` + ) + } else { + console.log(`${result.name}: N/A`) + } + } + if (failedCount > 0) { throw new Error(`${failedCount} test(s) failed`) } diff --git a/test/go/expect/gobenchmark-expect.json b/test/go/expect/gobenchmark-expect.json index ab85266b..11690f28 100644 --- a/test/go/expect/gobenchmark-expect.json +++ b/test/go/expect/gobenchmark-expect.json @@ -1 +1 @@ -{"/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_001_F/argument_passing_reference_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\nLine 17: __taint_sink(obj.\"data\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: argument_passing_reference_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: argument_passing_reference_002_T\n 28: CALL: argument_passing_reference_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: process\n 16: CALL: \tprocess(obj, __taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(obj[\"data\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_003_F/argument_passing_reference_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\nLine 15: __taint_sink(arr)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: argument_passing_reference_005_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: argument_passing_reference_005_T\n 26: CALL: argument_passing_reference_005_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_005_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: process\n 14: CALL: \tprocess(arr, __taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(arr)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_005_F/argument_passing_reference_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\nLine 17: __taint_sink(objB.\"name\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: argument_passing_reference_006_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: argument_passing_reference_006_T\n 30: CALL: argument_passing_reference_006_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_006_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: objA\n 13: Var Pass: \tobjA := map[string]interface{}{\"name\": __taint_src}\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: swap\n 16: CALL: \tswap(objA, objB)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(objB[\"name\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\nLine 20: __taint_sink(&person.GetNamePointer())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: argument_passing_reference_007_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: argument_passing_reference_007_T\n 34: CALL: argument_passing_reference_007_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func argument_passing_reference_007_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: UpdateNamePointer\n 19: CALL: \t(&person).UpdateNamePointer(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: &person\n 20: ARG PASS: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: &person\n 20: ARG PASS: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL RETURN: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink((&person).GetNamePointer())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_008_F/argument_passing_reference_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_011_F/argument_passing_value_011_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\nLine 16: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: argument_passing_value_012_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: argument_passing_value_012_T\n 23: CALL: argument_passing_value_012_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_012_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: process\n 12: CALL: \tprocess(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: arg\n 15: ARG PASS: func process(arg string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_013_F/argument_passing_value_013_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\nLine 18: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: argument_passing_value_014_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: argument_passing_value_014_T\n 28: CALL: argument_passing_value_014_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_014_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: process1\n 14: CALL: \tprocess1(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: arg\n 17: ARG PASS: func process1(arg interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_015_F/argument_passing_value_015_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\nLine 16: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: argument_passing_value_016_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: argument_passing_value_016_T\n 22: CALL: argument_passing_value_016_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_016_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: process\n 12: CALL: \tprocess(__taint_src, \"_\")\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: arg1\n 15: ARG PASS: func process(arg1 string, arg2 string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(arg1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_001_F/multiple_return_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\nLine 17: __taint_sink(ret1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: multiple_return_002_T\n 27: CALL: multiple_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_003_F/multiple_return_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\nLine 17: __taint_sink(ret2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_004_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: multiple_return_004_T\n 27: CALL: multiple_return_004_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_004_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_001_F/named_return_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\nLine 15: __taint_sink(ret)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: named_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: named_return_002_T\n 26: CALL: named_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func named_return_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: processData\n 14: CALL: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: processData\n 14: CALL RETURN: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: ret\n 14: Var Pass: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(ret)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_F/return_value_passing_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: return_value_passing_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: return_value_passing_002_T\n 24: CALL: return_value_passing_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func return_value_passing_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: process\n 12: CALL: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: process\n 12: CALL RETURN: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: data\n 12: Var Pass: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_001_F/multi_invoke_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\nLine 16: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multi_invoke_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: multi_invoke_002_T\n 27: CALL: multi_invoke_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multi_invoke_002_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: process\n 13: CALL: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: process\n 13: CALL RETURN: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: a\n 13: Var Pass: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(a)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\nLine 15: __taint_sink(sub.call(__taint_src))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_src\n 38: SOURCE: polymorphism_001_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: polymorphism_001_T\n 38: CALL: polymorphism_001_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func polymorphism_001_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: call\n 15: CALL: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: call\n 15: CALL RETURN: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(sub.call(__taint_src))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_002_F/polymorphism_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\nLine 15: __taint_sink(student.Run())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: polymorphism_003_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: polymorphism_003_T\n 46: CALL: polymorphism_003_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_003_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: student\n 12: Var Pass: \tvar student Person = &Student{Name: __taint_src, Age: 20, GPA: 3.8}\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: Run\n 15: CALL: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: student\n 15: ARG PASS: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: Run\n 15: CALL: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: student\n 15: ARG PASS: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: Run\n 15: CALL RETURN: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(student.Run())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_004_F/polymorphism_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\nLine 14: __taint_sink(str.0.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: array_index_005_T\n 21: CALL: array_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str[0][0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_006_F/array_index_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\nLine 18: __taint_sink(s.2.2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: slice_index_003_T\n 25: CALL: slice_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s[2][2])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_004_F/slice_index_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\nLine 14: __taint_sink(str.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: array_index_001_T\n 21: CALL: array_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_002_F/array_index_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\nLine 15: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: array_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: array_index_003_T\n 22: CALL: array_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_004_F/array_index_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\nLine 16: __taint_sink(m.\"key1\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: map_field_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: map_field_sensitive_001_T\n 23: CALL: map_field_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(m[\"key1\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_002_F/map_field_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_003_F/map_field_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\nLine 18: __taint_sink(m.\"key2\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: map_field_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: map_field_sensitive_004_T\n 25: CALL: map_field_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_004_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: m[\"key2\"]\n 16: Var Pass: \tm[\"key2\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(m[\"key2\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\nLine 17: __taint_sink(m.\"key1\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_src\n 24: SOURCE: map_field_sensitive_005_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: map_field_sensitive_005_F\n 24: CALL: map_field_sensitive_005_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_005_F(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(m[\"key1\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\nLine 14: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: slice_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: slice_index_001_T\n 21: CALL: slice_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: s\n 13: Var Pass: \tvar s []string = []string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_002_F/slice_index_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\nLine 16: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: slice_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: slice_index_005_T\n 23: CALL: slice_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: s\n 15: Var Pass: \ts = arr[:]\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\nLine 16: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: slice_index_006_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: slice_index_006_F\n 23: CALL: slice_index_006_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_006_F(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: s\n 15: Var Pass: \ts = arr[1:]\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_index_007_T/array_index_007_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_index_008_F/array_index_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\nLine 30: __taint_sink(c.b.a.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: field_len_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: field_len_001_T\n 37: CALL: field_len_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_src\n 22: ARG PASS: func field_len_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: pa\n 23: Var Pass: \tpa := A{\n 24: Var Pass: \t\tdata: __taint_src,\n 25: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: b.a\n 27: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: c.b\n 29: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(c.b.a.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_002_F/field_len_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\nLine 100: __taint_sink(q.p.o.n.m.l.k.j.i.h.g.f.e.d.c.b.a.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_src\n 107: SOURCE: field_len_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: field_len_003_T\n 107: CALL: field_len_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_src\n 64: ARG PASS: func field_len_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: pa\n 65: Var Pass: \tpa := A{\n 66: Var Pass: \t\tdata: __taint_src,\n 67: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: b.a\n 69: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: c.b\n 71: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: d.c\n 73: Var Pass: \td.c = c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: e.d\n 75: Var Pass: \te.d = d\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: f.e\n 77: Var Pass: \tf.e = e\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: g.f\n 79: Var Pass: \tg.f = f\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: h.g\n 81: Var Pass: \th.g = g\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: i.h\n 83: Var Pass: \ti.h = h\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: j.i\n 85: Var Pass: \tj.i = i\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: k.j\n 87: Var Pass: \tk.j = j\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: l.k\n 89: Var Pass: \tl.k = k\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: m.l\n 91: Var Pass: \tm.l = l\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: n.m\n 93: Var Pass: \tn.m = m\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: o.n\n 95: Var Pass: \to.n = n\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: p.o\n 97: Var Pass: \tp.o = o\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: q.p\n 99: Var Pass: \tq.p = p\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_sink\n 100: SINK: \t__taint_sink(q.p.o.n.m.l.k.j.i.h.g.f.e.d.c.b.a.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_004_F/field_len_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\nLine 47: __taint_sink(q)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_src\n 54: SOURCE: field_len_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: field_len_005_T\n 54: CALL: field_len_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_src\n 31: ARG PASS: func field_len_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: pa\n 32: Var Pass: \tpa := A{\n 33: Var Pass: \t\tdata: __taint_src,\n 34: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: b.a\n 36: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: c.b\n 38: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: d.c\n 40: Var Pass: \td.c = c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: e.d\n 42: Var Pass: \te.d = d\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: f.e\n 44: Var Pass: \tf.e = e\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: p\n 45: Var Pass: \tp := f.e.d.c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: q\n 46: Var Pass: \tq := p.b.a.data\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_sink\n 47: SINK: \t__taint_sink(q)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_006_F/field_len_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\nLine 22: __taint_sink(p.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: struct_field_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: struct_field_001_T\n 29: CALL: struct_field_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func struct_field_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: p\n 18: Var Pass: \tp := A{\n 19: Var Pass: \t\tdata: __taint_src,\n 20: Var Pass: \t\tsani: \"_\",\n 21: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_sink\n 22: SINK: \t__taint_sink(p.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_002_F/struct_field_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\nLine 21: __taint_sink(p1.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: struct_field_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: struct_field_003_T\n 28: CALL: struct_field_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func struct_field_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: p1.data\n 19: Var Pass: \tp1.data = __taint_src\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(p1.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_004_F/struct_field_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\nLine 19: __taint_sink(p1.string)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: struct_field_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: struct_field_005_T\n 26: CALL: struct_field_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_field_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: p1.string\n 18: Var Pass: \tp1.string = __taint_src\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(p1.string)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_006_F/struct_field_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/asynchronous/asynchronous_execution_001_T/asynchronous_execution_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/asynchronous/asynchronous_execution_002_F/asynchronous_execution_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/defer_exectution/defer_exectution_001_T/defer_exectution_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/defer_exectution/defer_exectution_002_F/defer_exectution_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_001_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: for_001_T\n 23: CALL: for_001_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_001_T(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_002_F(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: for_002_F\n 23: CALL: for_002_F(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_002_F(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_003_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: for_003_T\n 23: CALL: for_003_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_003_T(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: res\n 15: Var Pass: \tfor res = __taint_src; i < 1; i++ {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_004_F/for_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: array_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: array_obj_sensitive_001_T\n 23: CALL: array_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_002_F/array_obj_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: array_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: array_obj_sensitive_003_T\n 23: CALL: array_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_004_F/array_obj_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: array_obj_sensitive_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: array_obj_sensitive_007_T\n 22: CALL: array_obj_sensitive_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_007_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [...]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_008_F/array_obj_sensitive_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\nLine 17: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: map_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: map_obj_sensitive_001_T\n 24: CALL: map_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: m[\"key1\"]\n 15: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\nLine 15: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: map_obj_sensitive_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: map_obj_sensitive_002_T\n 22: CALL: map_obj_sensitive_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_002_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_003_F/map_obj_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\nLine 20: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: map_obj_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: map_obj_sensitive_004_T\n 27: CALL: map_obj_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_004_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: m\n 13: Var Pass: \tm := map[string]string{\n 14: Var Pass: \t\t\"key1\": __taint_src,\n 15: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_005_F/map_obj_sensitive_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\nLine 18: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_001slice_obj_sensitive_001_T_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: slice_001slice_obj_sensitive_001_T_T\n 25: CALL: slice_001slice_obj_sensitive_001_T_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_001slice_obj_sensitive_001_T_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: s\n 17: Var Pass: \ts = arr[:]\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_002_F/slice_obj_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\nLine 24: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: slice_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: slice_obj_sensitive_003_T\n 31: CALL: slice_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_obj_sensitive_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_004_F/slice_obj_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_001_F/interface_class_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\nLine 41: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_src\n 48: SOURCE: interface_class_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: interface_class_002_T\n 48: CALL: interface_class_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_src\n 38: ARG PASS: func interface_class_002_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: process\n 40: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: process\n 40: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: res\n 40: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_sink\n 41: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_003_F/interface_class_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\nLine 47: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_src\n 54: SOURCE: interface_class_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: interface_class_004_T\n 54: CALL: interface_class_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_src\n 44: ARG PASS: func interface_class_004_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: process\n 46: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: process\n 46: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: res\n 46: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_sink\n 47: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_005_F/interface_class_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\nLine 39: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: interface_class_006_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: interface_class_006_T\n 46: CALL: interface_class_006_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_src\n 36: ARG PASS: func interface_class_006_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: process\n 38: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: process\n 38: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: res\n 38: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_sink\n 39: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_007_F/interface_class_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\nLine 34: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_src\n 41: SOURCE: interface_class_008_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: interface_class_008_T\n 41: CALL: interface_class_008_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_src\n 31: ARG PASS: func interface_class_008_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: process\n 33: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: process\n 33: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: res\n 33: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_sink\n 34: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_009_F/interface_class_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_010_T/interface_class_010_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_011_F/interface_class_011_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\nLine 46: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\",\"functionName\":\"interface_class_012_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: __taint_src\n 43: SOURCE: func interface_class_012_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: processArg\n 45: CALL: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: processArg\n 45: CALL RETURN: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: res\n 45: Var Pass: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: __taint_sink\n 46: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\nLine 24: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: struct_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: struct_007_T\n 31: CALL: struct_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_007_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{\n 18: Var Pass: \t\tdata: __taint_src,\n 19: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_008_F/struct_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\nLine 57: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_src\n 65: SOURCE: struct_deep10_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: struct_deep10_001_T\n 65: CALL: struct_deep10_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_src\n 50: ARG PASS: func struct_deep10_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: obj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11\n 55: Var Pass: \tobj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_sink\n 57: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\nLine 57: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_src\n 65: SOURCE: struct_deep10_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: struct_deep10_002_F\n 65: CALL: struct_deep10_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_src\n 50: ARG PASS: func struct_deep10_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: obj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11\n 55: Var Pass: \tobj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_sink\n 57: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\nLine 31: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_src\n 39: SOURCE: struct_deep3_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: struct_deep3_001_T\n 39: CALL: struct_deep3_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: obj1.deepC02.deepC03.deepC04\n 29: Var Pass: \tobj1.deepC02.deepC03.deepC04 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_sink\n 31: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\nLine 30: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_src\n 38: SOURCE: struct_deep3_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: struct_deep3_002_F\n 38: CALL: struct_deep3_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: obj1.deepC02.deepC03.deepC04\n 29: Var Pass: \tobj1.deepC02.deepC03.deepC04 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\nLine 34: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_src\n 42: SOURCE: struct_deep3_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: struct_deep3_003_T\n 42: CALL: struct_deep3_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: deepC03\n 29: Var Pass: \tdeepC03 := DeepC03{\n 30: Var Pass: \t\tdeepC04: __taint_src,\n 31: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: obj1.deepC02.deepC03\n 32: Var Pass: \tobj1.deepC02.deepC03 = deepC03\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_sink\n 34: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_004_F/struct_deep3_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\nLine 35: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_src\n 43: SOURCE: struct_deep5_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: struct_deep5_001_T\n 43: CALL: struct_deep5_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_src\n 28: ARG PASS: func struct_deep5_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 33: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\nLine 35: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_src\n 43: SOURCE: struct_deep5_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: struct_deep5_002_F\n 43: CALL: struct_deep5_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_src\n 28: ARG PASS: func struct_deep5_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 33: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\nLine 42: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_src\n 50: SOURCE: struct_deep5_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: struct_deep5_003_T\n 50: CALL: struct_deep5_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_src\n 32: ARG PASS: func struct_deep5_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: deepB05\n 37: Var Pass: \tdeepB05 := DeepB05{\n 38: Var Pass: \t\tdeepB06: __taint_src,\n 39: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 40: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = deepB05\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_sink\n 42: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\nLine 42: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_src\n 50: SOURCE: struct_deep5_004_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: struct_deep5_004_F\n 50: CALL: struct_deep5_004_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_src\n 32: ARG PASS: func struct_deep5_004_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: deepB05\n 37: Var Pass: \tdeepB05 := DeepB05{\n 38: Var Pass: \t\tdeepB06: __taint_src,\n 39: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 40: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = deepB05\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_sink\n 42: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: break_003_T\n 25: CALL: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(res)\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: break_003_T\n 25: CALL: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: CALL: \t\t__taint_sink(res)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: break_004_F\n 26: CALL: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t\t__taint_sink(res)\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: break_004_F\n 26: CALL: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: CALL: \t\t__taint_sink(res)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: break_label_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: break_label_003_T\n 27: CALL: break_label_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_label_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_src\n 27: SOURCE: break_label_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: break_label_004_F\n 27: CALL: break_label_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_label_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: continue_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: continue_003_T\n 26: CALL: continue_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func continue_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: continue_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: continue_004_F\n 26: CALL: continue_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func continue_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_003_T/fallthrough_003_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\nLine 24: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_src\n 30: SOURCE: fallthrough_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: fallthrough_004_F\n 30: CALL: fallthrough_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func fallthrough_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/goto_003_T/goto_003_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/goto_004_F/goto_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: return_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: return_003_T\n 23: CALL: return_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_003_T(__taint_src string) string {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: return_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: return_004_F\n 23: CALL: return_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_004_F(__taint_src string) string {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_src\n 24: SOURCE: conditional_if_005_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: conditional_if_005_F\n 24: CALL: conditional_if_005_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_005_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_006_F/conditional_if_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: conditional_if_007_T\n 25: CALL: conditional_if_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_007_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: conditional_if_008_F\n 25: CALL: conditional_if_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_008_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_003_F/conditional_switch_stmt_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_004_F/conditional_switch_stmt_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_005_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: conditional_switch_stmt_005_T\n 26: CALL: conditional_switch_stmt_005_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_005_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_006_F/conditional_switch_stmt_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_009_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: conditional_if_009_T\n 25: CALL: conditional_if_009_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_009_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_010_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: conditional_if_010_F\n 25: CALL: conditional_if_010_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_010_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: conditional_switch_stmt_007_T\n 26: CALL: conditional_switch_stmt_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_007_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: conditional_switch_stmt_008_F\n 26: CALL: conditional_switch_stmt_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_008_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_body_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: for_body_003_T\n 23: CALL: for_body_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_body_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_src\n 22: SOURCE: for_body_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: for_body_004_F\n 22: CALL: for_body_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func for_body_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: res\n 14: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\nLine 26: __taint_sink(s.Field(i))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: reflect_call_001_T\n 34: CALL: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 21: ARG PASS: func reflect_call_001_T(__taint_src string) {\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: t\n 22: Var Pass: \tt := T{123, __taint_src}\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: s\n 23: Var Pass: \ts := reflect.ValueOf(t)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(s.Field(i))\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\nLine 26: __taint_sink(s.Field(i))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: reflect_call_001_T\n 34: CALL: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 21: ARG PASS: func reflect_call_001_T(__taint_src string) {\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: t\n 22: Var Pass: \tt := T{123, __taint_src}\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: s\n 23: Var Pass: \ts := reflect.ValueOf(t)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: CALL: \t\t__taint_sink(s.Field(i))\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(s.Field(i))\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_002_F/reflect_call_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/alias/alias_001_F/alias_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\nLine 21: __taint_sink(a.Value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: alias_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: alias_002_T\n 28: CALL: alias_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func alias_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: b.Value\n 19: Var Pass: \tb.Value = __taint_src\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(a.Value)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\nLine 17: __taint_sink(popch)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: asynchronous_goroutine_channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: asynchronous_goroutine_channel_001_T\n 24: CALL: asynchronous_goroutine_channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func asynchronous_goroutine_channel_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(<-ch)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_002_F/asynchronous_goroutine_channel_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\nLine 30: __taint_sink(message)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_src\n 40: SOURCE: asynchronous_goroutine_channel_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: asynchronous_goroutine_channel_003_T\n 40: CALL: asynchronous_goroutine_channel_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func asynchronous_goroutine_channel_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t\t__taint_sink(message)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_004_F/asynchronous_goroutine_channel_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\nLine 33: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_src\n 45: SOURCE: asynchronous_multiple_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: asynchronous_multiple_select_001_T\n 45: CALL: asynchronous_multiple_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func asynchronous_multiple_select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: result\n 22: Var Pass: \t\tresult := __taint_src\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_sink\n 33: SINK: \t\t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_002_F/asynchronous_multiple_select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\nLine 26: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_src\n 36: SOURCE: asynchronous_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: asynchronous_select_001_T\n 36: CALL: asynchronous_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func asynchronous_select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_002_F/asynchronous_select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: synchronization_primitive_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: synchronization_primitive_001_T\n 22: CALL: synchronization_primitive_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func synchronization_primitive_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_002_F/synchronization_primitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: synchronization_primitive_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: synchronization_primitive_003_T\n 25: CALL: synchronization_primitive_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func synchronization_primitive_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_004_F/synchronization_primitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: conditional_if_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: conditional_if_001_T\n 21: CALL: conditional_if_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F/conditional_if_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: conditional_if_003_T\n 25: CALL: conditional_if_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_004_F/conditional_if_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\nLine 15: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: conditional_switch_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: conditional_switch_001_T\n 22: CALL: conditional_switch_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_002_F/conditional_switch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\nLine 16: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: conditional_switch_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: conditional_switch_003_T\n 23: CALL: conditional_switch_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: data\n 14: Var Pass: \tswitch data := __taint_src; data {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_004_F/conditional_switch_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\nLine 22: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: conditional_switch_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: conditional_switch_005_T\n 30: CALL: conditional_switch_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_sink\n 22: SINK: \t\t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_006_F/conditional_switch_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: select_001_T\n 27: CALL: select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_002_F/select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: for_body_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: for_body_001_T\n 24: CALL: for_body_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_body_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_002_F/for_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: for_init_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: for_init_001_T\n 25: CALL: for_init_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_init_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: ini\n 16: Var Pass: \tfor ini = __taint_src; j < 10; j++ {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = res + ini\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_002_F/for_init_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: for_range_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: for_range_001_T\n 22: CALL: for_range_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_range_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: m\n 13: Var Pass: \tvar m = map[string]string{\"a\": __taint_src, \"b\": \"2\"}\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_002_F/for_range_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: for_update_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: for_update_001_T\n 26: CALL: for_update_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_update_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: j\n 16: Var Pass: \tfor ; ini < 2; j = __taint_src {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = j\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_002_F/for_update_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: array_001_T\n 21: CALL: array_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_002_F/array_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: array_003_T\n 21: CALL: array_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_004_F/array_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: array_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: array_005_T\n 20: CALL: array_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_005_T(__taint_src [3]string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_006_F/array_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: array_007_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: array_007_T\n 20: CALL: array_007_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_007_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [...]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_008_F/array_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\nLine 16: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: generics_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: generics_001_T\n 23: CALL: generics_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_src\n 14: ARG PASS: func generics_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: s\n 15: Var Pass: \tvar s Slice[string] = []string{\"a\", \"b\", __taint_src}\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_002_F/generics_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\nLine 15: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: map_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: map_001_T\n 22: CALL: map_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_002_F/map_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\nLine 16: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: map_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: map_003_T\n 23: CALL: map_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: m\n 13: Var Pass: \tm := map[string]string{\n 14: Var Pass: \t\t\"key1\": __taint_src,\n 15: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_004_F/map_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\nLine 14: __taint_sink(*ps)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: pointer_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: pointer_001_T\n 21: CALL: pointer_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func pointer_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: ps\n 13: Var Pass: \tps := &__taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(*ps)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_002_F/pointer_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\nLine 16: __taint_sink(*ps)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: pointer_new_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: pointer_new_001_T\n 23: CALL: pointer_new_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func pointer_new_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n 15: Var Pass: \t*ps = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(*ps)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_002_F/pointer_new_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_src\n 19: SOURCE: primitives_bool_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: primitives_bool_001_T\n 19: CALL: primitives_bool_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_bool_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_002_F/primitives_bool_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_complex_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: primitives_complex_001_T\n 20: CALL: primitives_complex_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_complex_001_T(__taint_src complex64) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_002_F/primitives_complex_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_float_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: primitives_float_001_T\n 20: CALL: primitives_float_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_float_001_T(__taint_src float64) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_002_F/primitives_float_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_int_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: primitives_int_001_T\n 20: CALL: primitives_int_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_int_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_002_F/primitives_int_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: slice_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: slice_001_T\n 20: CALL: slice_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: s\n 13: Var Pass: \tvar s []string = []string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_002_F/slice_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\nLine 15: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: slice_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: slice_003_T\n 22: CALL: slice_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: s\n 14: Var Pass: \ts = append(s, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_004_F/slice_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\nLine 18: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: slice_005_T\n 25: CALL: slice_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_006_F/slice_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_007_T/slice_007_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_008_F/slice_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\nLine 17: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: channel_001_T\n 23: CALL: channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func channel_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(c)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_002_F/channel_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: string_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: string_001_T\n 20: CALL: string_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func string_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/string/string_002_F/string_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\nLine 30: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: complex_struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: complex_struct_001_T\n 37: CALL: complex_struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_src\n 13: ARG PASS: func complex_struct_001_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: Say\n 16: CALL: \ta.b.Say(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: c\n 29: ARG PASS: func (b B) Say(c interface{}) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(c)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_002_F/complex_struct_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\nLine 20: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: struct_001_T\n 27: CALL: struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{\n 18: Var Pass: \t\tdata: __taint_src,\n 19: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_002_F/struct_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\nLine 19: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: struct_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: struct_003_T\n 26: CALL: struct_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: p.data\n 18: Var Pass: \tp.data = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_004_F/struct_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\nLine 18: __taint_sink(p.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: struct_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: struct_005_T\n 24: CALL: struct_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{__taint_src}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(p.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_006_F/struct_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\nLine 25: __taint_sink(pb)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_src\n 32: SOURCE: struct_cross_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: struct_cross_001_T\n 32: CALL: struct_cross_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_src\n 19: ARG PASS: func struct_cross_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: pa\n 20: Var Pass: \tpa := A{\n 21: Var Pass: \t\tdata: __taint_src,\n 22: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: pb.data\n 24: Var Pass: \tpb.data = pa.data\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_sink\n 25: SINK: \t__taint_sink(pb)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_002_F/struct_cross_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\nLine 24: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: struct_cross_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: struct_cross_003_T\n 30: CALL: struct_cross_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_src\n 20: ARG PASS: func struct_cross_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: p\n 21: Var Pass: \tp := B{A{\n 22: Var Pass: \t\tdata: __taint_src,\n 23: Var Pass: \t}, \"_\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_004_F/struct_cross_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/exception_error/exception_throw/exception_throw_001_T/exception_throw_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/exception_error/exception_throw/exception_throw_002_F/exception_throw_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: assign_expression_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: assign_expression_001_T\n 20: CALL: assign_expression_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func assign_expression_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_002_F/assign_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: binary_expression_add_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: binary_expression_add_001_T\n 20: CALL: binary_expression_add_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func binary_expression_add_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src + \"_\"\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_002_F/binary_expression_add_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: binary_expression_add_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: binary_expression_add_assignment_001_T\n 21: CALL: binary_expression_add_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func binary_expression_add_assignment_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_002_F/binary_expression_add_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: bitwise_expression_and_001_T\n 20: CALL: bitwise_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_and_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src & 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_002_F/bitwise_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_lsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: bitwise_expression_lsh_001_T\n 20: CALL: bitwise_expression_lsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_lsh_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src << 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_002_F/bitwise_expression_lsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_not_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: bitwise_expression_not_001_T\n 20: CALL: bitwise_expression_not_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_not_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_002_F/bitwise_expression_not_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: bitwise_expression_or_001_T\n 20: CALL: bitwise_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_or_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src | 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_002_F/bitwise_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_rsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: bitwise_expression_rsh_001_T\n 20: CALL: bitwise_expression_rsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_rsh_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src >> 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_002_F/bitwise_expression_rsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: bitwise_expression_xor_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: bitwise_expression_xor_001_T\n 21: CALL: bitwise_expression_xor_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_xor_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src ^ 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_002_F/bitwise_expression_xor_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: logic_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: logic_expression_and_001_T\n 20: CALL: logic_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func logic_expression_and_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src && true\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_F/logic_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: logic_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: logic_expression_or_001_T\n 20: CALL: logic_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func logic_expression_or_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := false || __taint_src\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_002_F/logic_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: relation_expression_equal_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: relation_expression_equal_001_T\n 21: CALL: relation_expression_equal_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func relation_expression_equal_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src == \"__taint_src\"\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F/relation_expression_equal_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\nLine 14: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: blank_identifier_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: blank_identifier_001_T\n 25: CALL: blank_identifier_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func blank_identifier_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: getData\n 13: CALL: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: getData\n 13: CALL RETURN: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n 13: Var Pass: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(a)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_002_F/blank_identifier_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: multiple_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: multiple_assignment_001_T\n 21: CALL: multiple_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_assignment_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_002_F/multiple_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\nLine 17: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: rest_parameter_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: rest_parameter_001_T\n 24: CALL: rest_parameter_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func rest_parameter_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: collectArgs\n 13: CALL: \tcollectArgs(\"prefix\", __taint_src, \"suffix\")\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: args\n 16: ARG PASS: func collectArgs(args ...interface{}) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(args)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_002_F/rest_parameter_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\nLine 15: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: spread_operator_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: spread_operator_001_T\n 22: CALL: spread_operator_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func spread_operator_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: array1\n 13: Var Pass: \tarray1 := []string{\"a\", \"b\", __taint_src}\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: array\n 14: Var Pass: \tarray := append([]string{\"c\"}, array1...)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(array)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_002_F/spread_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: type_cast_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: type_cast_001_T\n 21: CALL: type_cast_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func type_cast_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := float64(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_002_F/type_cast_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: type_cast_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: type_cast_003_T\n 22: CALL: type_cast_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func type_cast_003_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n 13: Var Pass: \tresult, ok := __taint_src.(string)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_004_F/type_cast_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_001_F/anonymous_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\nLine 16: __taint_sink(process(__taint_src, \"foo\"))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: anonymous_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: anonymous_function_002_T\n 23: CALL: anonymous_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: \n 16: CALL: \t__taint_sink(process(__taint_src, \"foo\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: a\n 13: ARG PASS: \tprocess := func(a string, b string) string {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn a + b\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: \n 16: CALL RETURN: \t__taint_sink(process(__taint_src, \"foo\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(process(__taint_src, \"foo\"))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_003_F/anonymous_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\nLine 15: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: anonymous_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: anonymous_function_004_T\n 25: CALL: anonymous_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: \n 18: CALL: \tprocess(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: input\n 14: ARG PASS: \tprocess := func(input interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(input)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_005_F/anonymous_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: anonymous_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: anonymous_function_006_T\n 22: CALL: anonymous_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_001_F/closure_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: closure_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: closure_function_002_T\n 23: CALL: closure_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_002_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_003_F/closure_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\nLine 15: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: closure_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: closure_function_004_T\n 26: CALL: closure_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_005_F/closure_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\nLine 35: __taint_sink(a.update())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_src\n 42: SOURCE: closure_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: closure_function_006_T\n 42: CALL: closure_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_src\n 13: ARG PASS: func closure_function_006_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: source\n 25: Var Pass: \t\t\t\tsource = __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: [return value]\n 26: Return Value: \t\t\t\treturn source\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: \n 35: CALL RETURN: \t__taint_sink(a.update())\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(a.update())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_F/closure_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\nLine 20: __taint_sink(middleVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_src\n 38: SOURCE: closure_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: closure_function_008_T\n 38: CALL: closure_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_008_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: outerVar\n 14: Var Pass: \t\touterVar := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: middleVar\n 17: Var Pass: \t\t\tmiddleVar := outerVar\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t\t\t\t__taint_sink(middleVar)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_F/closure_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\nLine 18: __taint_sink(outerVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_src\n 36: SOURCE: closure_function_010_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: closure_function_010_T\n 36: CALL: closure_function_010_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_010_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: outerVar\n 14: Var Pass: \t\touterVar := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t\t\t__taint_sink(outerVar)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_001_F/argument_passing_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\nLine 17: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: argument_passing_value_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: argument_passing_value_002_T\n 24: CALL: argument_passing_value_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: process\n 13: CALL: \tprocess(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: arg\n 16: ARG PASS: func process(arg string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_003_F/argument_passing_value_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\nLine 19: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: argument_passing_value_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: argument_passing_value_004_T\n 29: CALL: argument_passing_value_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: process1\n 15: CALL: \tprocess1(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: arg\n 18: ARG PASS: func process1(arg interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_005_F/argument_passing_value_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\nLine 17: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: argument_passing_value_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: argument_passing_value_006_T\n 23: CALL: argument_passing_value_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_006_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: process\n 13: CALL: \tprocess(__taint_src, \"_\")\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: arg1\n 16: ARG PASS: func process(arg1 string, arg2 string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(arg1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_007_F/argument_passing_value_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\nLine 15: __taint_sink(innerInput)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: argument_passing_value_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: argument_passing_value_008_T\n 27: CALL: argument_passing_value_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_008_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: \n 21: CALL: \touter(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: input\n 13: ARG PASS: \touter := func(input string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: \n 18: CALL: \t\tinner(input)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: innerInput\n 14: ARG PASS: \t\tinner := func(innerInput interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t\t__taint_sink(innerInput)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\nLine 20: __taint_sink(person.GetNamePointer())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_src\n 35: SOURCE: argument_passing_value_009_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: argument_passing_value_009_T\n 35: CALL: argument_passing_value_009_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func argument_passing_value_009_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: person\n 17: Var Pass: \tperson := Person{Name: __taint_src}\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: UpdateNamePointer\n 19: CALL: \tperson.UpdateNamePointer(\"safe\")\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: person\n 19: ARG PASS: \tperson.UpdateNamePointer(\"safe\")\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: person\n 20: ARG PASS: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: person\n 20: ARG PASS: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL RETURN: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(person.GetNamePointer())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_010_F/argument_passing_value_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_001_F/chained_call_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\nLine 31: __taint_sink(a.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: chained_call_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: chained_call_002_T\n 37: CALL: chained_call_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func chained_call_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: setName\n 13: CALL: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: setName\n 13: CALL RETURN: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: process\n 13: CALL: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: new A().setName(\"_\").clearName().setName(__taint_s\n 13: ARG PASS: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_sink\n 31: SINK: \t__taint_sink(a.name)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_003_F/chained_call_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\nLine 39: __taint_sink(b.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: chained_call_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: chained_call_004_T\n 46: CALL: chained_call_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func chained_call_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetName\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetName\n 13: CALL RETURN: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetOther\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: NewB().SetName(__taint_src)\n 13: ARG PASS: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetOther\n 13: CALL RETURN: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: Process\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: NewB().SetName(__taint_src).SetOther()\n 13: ARG PASS: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_sink\n 39: SINK: \t__taint_sink(b.name)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_001_F/higher_order_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\nLine 20: __taint_sink(f(__taint_src, \"_\")())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: higher_order_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: higher_order_function_002_T\n 27: CALL: higher_order_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: \n 20: CALL: \t__taint_sink(f(__taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: a\n 13: ARG PASS: \tf := func(a string, b string) func() string {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: [return value]\n 16: Return Value: \t\t\treturn a + b + c\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: \n 20: CALL RETURN: \t__taint_sink(f(__taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(f(__taint_src, \"_\")())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_003_F/higher_order_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\nLine 24: __taint_sink(f(g, __taint_src, \"_\"))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: higher_order_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: higher_order_function_004_T\n 31: CALL: higher_order_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 24: CALL: \t__taint_sink(f(g, __taint_src, \"_\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: a\n 13: ARG PASS: \tf := func(g func(string, string) func() string, a string, b string) string {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 14: CALL: \t\treturn g(a, b)()\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: a\n 17: ARG PASS: \tg := func(a string, b string) func() string {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: [return value]\n 20: Return Value: \t\t\treturn a + b + c\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 14: CALL RETURN: \t\treturn g(a, b)()\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn g(a, b)()\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 24: CALL RETURN: \t__taint_sink(f(g, __taint_src, \"_\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(f(g, __taint_src, \"_\"))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_005_F/higher_order_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\nLine 13: __taint_sink(f(g, u, __taint_src, \"_\")())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_src\n 35: SOURCE: higher_order_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: higher_order_function_006_T\n 35: CALL: higher_order_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: f\n 13: CALL: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: \n 13: CALL RETURN: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_007_F/higher_order_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: higher_order_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: higher_order_function_008_T\n 27: CALL: higher_order_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_008_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: higher_order_function_008_Function\n 13: CALL: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n 14: CALL: \t\treturn a + b\n 15: CALL: \t}, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: a\n 13: ARG PASS: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn a + b\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: higher_order_function_008_Function\n 13: CALL RETURN: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n 14: CALL RETURN: \t\treturn a + b\n 15: CALL RETURN: \t}, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n 14: Var Pass: \t\treturn a + b\n 15: Var Pass: \t}, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_arg_001_T/arg_arg_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_arg_002_F/arg_arg_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: arg_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: arg_return_001_T\n 28: CALL: arg_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func arg_return_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: taintedData\n 13: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: appendTaint\n 15: CALL: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: appendTaint\n 15: CALL RETURN: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: result\n 15: Var Pass: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_002_F/arg_return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: arg_return_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: arg_return_003_T\n 29: CALL: arg_return_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_src\n 14: ARG PASS: func arg_return_003_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: taintedData\n 15: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: itoaTaint\n 16: CALL: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: itoaTaint\n 16: CALL RETURN: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: result\n 16: Var Pass: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_004_F/arg_return_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: this_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: this_return_001_T\n 27: CALL: this_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func this_return_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintedData\n 13: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintToString\n 14: CALL: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintToString\n 14: CALL RETURN: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: result\n 14: Var Pass: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_002_F/this_return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\nLine 14: __taint_sink(sub.call(__taint_src))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: polymorphism_override_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: polymorphism_override_001_T\n 37: CALL: polymorphism_override_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_override_001_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: call\n 14: CALL: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: call\n 14: CALL RETURN: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(sub.call(__taint_src))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_002_F/polymorphism_override_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\nLine 15: __taint_sink(student.Run())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: polymorphism_override_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: polymorphism_override_003_T\n 46: CALL: polymorphism_override_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_override_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: student\n 12: Var Pass: \tvar student Person = &Student{Name: __taint_src, Age: 20, GPA: 3.8}\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: Run\n 15: CALL: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: student\n 15: ARG PASS: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: Run\n 15: CALL: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: student\n 15: ARG PASS: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: Run\n 15: CALL RETURN: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(student.Run())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_004_F/polymorphism_override_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_005_F/multiple_return_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\nLine 17: __taint_sink(ret1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: multiple_return_006_T\n 27: CALL: multiple_return_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_003_F/named_return_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\nLine 16: __taint_sink(ret)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: named_return_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: named_return_004_T\n 27: CALL: named_return_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func named_return_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: processData\n 15: CALL: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: ret\n 15: Var Pass: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(ret)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_003_F/return_value_passing_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\nLine 14: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: return_value_passing_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: return_value_passing_004_T\n 25: CALL: return_value_passing_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_value_passing_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: process\n 13: CALL: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: process\n 13: CALL RETURN: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: data\n 13: Var Pass: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_src\n 58: SOURCE: interface_class_001_c_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: interface_class_001_c_T\n 58: CALL: interface_class_001_c_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func interface_class_001_c_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: GetTest\n 19: CALL: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: GetTest\n 19: CALL RETURN: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n 19: Var Pass: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_002_c_F/interface_class_002_c_F":"======================== Findings ========================\nNo findings!\n=========================================================="} \ No newline at end of file +{"/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_001_F/argument_passing_reference_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\nLine 17: __taint_sink(obj.\"data\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: argument_passing_reference_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: argument_passing_reference_002_T\n 28: CALL: argument_passing_reference_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: process\n 16: CALL: \tprocess(obj, __taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_002_T/argument_passing_reference_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(obj[\"data\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_003_F/argument_passing_reference_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\nLine 15: __taint_sink(arr)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: argument_passing_reference_005_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: argument_passing_reference_005_T\n 26: CALL: argument_passing_reference_005_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_005_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: process\n 14: CALL: \tprocess(arr, __taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_004_T/argument_passing_reference_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(arr)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_005_F/argument_passing_reference_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\nLine 17: __taint_sink(objB.\"name\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: argument_passing_reference_006_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: argument_passing_reference_006_T\n 30: CALL: argument_passing_reference_006_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_reference_006_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: objA\n 13: Var Pass: \tobjA := map[string]interface{}{\"name\": __taint_src}\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: swap\n 16: CALL: \tswap(objA, objB)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_006_T/argument_passing_reference_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(objB[\"name\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\nLine 20: __taint_sink(&person.GetNamePointer())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: argument_passing_reference_007_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: argument_passing_reference_007_T\n 34: CALL: argument_passing_reference_007_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func argument_passing_reference_007_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: UpdateNamePointer\n 19: CALL: \t(&person).UpdateNamePointer(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL RETURN: \t__taint_sink((&person).GetNamePointer())\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_007_T/argument_passing_reference_007_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink((&person).GetNamePointer())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_reference_008_F/argument_passing_reference_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_011_F/argument_passing_value_011_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\nLine 16: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: argument_passing_value_012_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: argument_passing_value_012_T\n 23: CALL: argument_passing_value_012_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_012_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: process\n 12: CALL: \tprocess(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: arg\n 15: ARG PASS: func process(arg string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_012_T/argument_passing_value_012_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_013_F/argument_passing_value_013_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\nLine 18: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: argument_passing_value_014_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: argument_passing_value_014_T\n 28: CALL: argument_passing_value_014_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_014_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: process1\n 14: CALL: \tprocess1(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: arg\n 17: ARG PASS: func process1(arg interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_014_T/argument_passing_value_014_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_015_F/argument_passing_value_015_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\nLine 16: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: argument_passing_value_016_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: argument_passing_value_016_T\n 22: CALL: argument_passing_value_016_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func argument_passing_value_016_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: process\n 12: CALL: \tprocess(__taint_src, \"_\")\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: arg1\n 15: ARG PASS: func process(arg1 string, arg2 string) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_016_T/argument_passing_value_016_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(arg1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_001_F/multiple_return_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\nLine 17: __taint_sink(ret1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: multiple_return_002_T\n 27: CALL: multiple_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_002_T/multiple_return_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_003_F/multiple_return_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\nLine 17: __taint_sink(ret2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_004_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: multiple_return_004_T\n 27: CALL: multiple_return_004_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_004_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/multiple_return_004_T/multiple_return_004_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_001_F/named_return_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\nLine 15: __taint_sink(ret)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: named_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: named_return_002_T\n 26: CALL: named_return_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func named_return_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: processData\n 14: CALL: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: processData\n 14: CALL RETURN: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: ret\n 14: Var Pass: \tret := processData(__taint_src, a)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/named_return_002_T/named_return_002_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(ret)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_F/return_value_passing_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: return_value_passing_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: return_value_passing_002_T\n 24: CALL: return_value_passing_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func return_value_passing_002_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: process\n 12: CALL: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: process\n 12: CALL RETURN: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: data\n 12: Var Pass: \tdata := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_T/return_value_passing_002_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_001_F/multi_invoke_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\nLine 16: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multi_invoke_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: multi_invoke_002_T\n 27: CALL: multi_invoke_002_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multi_invoke_002_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: process\n 13: CALL: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: process\n 13: CALL RETURN: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: a\n 13: Var Pass: \ta := process(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/multi_invoke/multi_invoke_002_T/multi_invoke_002_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(a)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\nLine 15: __taint_sink(sub.call(__taint_src))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_src\n 38: SOURCE: polymorphism_001_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: polymorphism_001_T\n 38: CALL: polymorphism_001_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func polymorphism_001_T(__taint_src interface{}) {\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: call\n 15: CALL: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: call\n 15: CALL RETURN: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_001_T/polymorphism_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(sub.call(__taint_src))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_002_F/polymorphism_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\nLine 15: __taint_sink(student.Run())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: polymorphism_003_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: polymorphism_003_T\n 46: CALL: polymorphism_003_T(__taint_src)\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_003_T(__taint_src string) {\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: student\n 12: Var Pass: \tvar student Person = &Student{Name: __taint_src, Age: 20, GPA: 3.8}\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: Run\n 15: CALL RETURN: \t__taint_sink(student.Run())\n /sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_003_T/polymorphism_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(student.Run())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/context_sensitive/polymorphism/polymorphism_004_F/polymorphism_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\nLine 14: __taint_sink(str.0.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: array_index_005_T\n 21: CALL: array_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_005_T/array_index_005_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str[0][0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/array_index_006_F/array_index_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\nLine 18: __taint_sink(s.2.2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: slice_index_003_T\n 25: CALL: slice_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_003_T/slice_index_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s[2][2])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/multidimensional_collection/slice_index_004_F/slice_index_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\nLine 14: __taint_sink(str.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: array_index_001_T\n 21: CALL: array_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_001_T/array_index_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_002_F/array_index_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\nLine 15: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: array_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: array_index_003_T\n 22: CALL: array_index_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_index_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_003_T/array_index_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_index_004_F/array_index_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\nLine 16: __taint_sink(m.\"key1\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: map_field_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: map_field_sensitive_001_T\n 23: CALL: map_field_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T/map_field_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(m[\"key1\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_002_F/map_field_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_003_F/map_field_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\nLine 18: __taint_sink(m.\"key2\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: map_field_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: map_field_sensitive_004_T\n 25: CALL: map_field_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_004_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: m[\"key2\"]\n 16: Var Pass: \tm[\"key2\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T/map_field_sensitive_004_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(m[\"key2\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\nLine 17: __taint_sink(m.\"key1\")\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_src\n 24: SOURCE: map_field_sensitive_005_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: map_field_sensitive_005_F\n 24: CALL: map_field_sensitive_005_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_field_sensitive_005_F(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F/map_field_sensitive_005_F.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(m[\"key1\"])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\nLine 14: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: slice_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: slice_index_001_T\n 21: CALL: slice_index_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: s\n 13: Var Pass: \tvar s []string = []string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_001_T/slice_index_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_002_F/slice_index_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\nLine 16: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: slice_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: slice_index_005_T\n 23: CALL: slice_index_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: s\n 15: Var Pass: \ts = arr[:]\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_005_T/slice_index_005_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\nLine 16: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: slice_index_006_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: slice_index_006_F\n 23: CALL: slice_index_006_F(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_index_006_F(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: s\n 15: Var Pass: \ts = arr[1:]\n /sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/slice_index_006_F/slice_index_006_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s[0])\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_index_007_T/array_index_007_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_index_008_F/array_index_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\nLine 30: __taint_sink(c.b.a.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: field_len_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: field_len_001_T\n 37: CALL: field_len_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_src\n 22: ARG PASS: func field_len_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: pa\n 23: Var Pass: \tpa := A{\n 24: Var Pass: \t\tdata: __taint_src,\n 25: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: b.a\n 27: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: c.b\n 29: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_001_T/field_len_001_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(c.b.a.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_002_F/field_len_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\nLine 100: __taint_sink(q.p.o.n.m.l.k.j.i.h.g.f.e.d.c.b.a.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_src\n 107: SOURCE: field_len_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: field_len_003_T\n 107: CALL: field_len_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_src\n 64: ARG PASS: func field_len_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: pa\n 65: Var Pass: \tpa := A{\n 66: Var Pass: \t\tdata: __taint_src,\n 67: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: b.a\n 69: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: c.b\n 71: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: d.c\n 73: Var Pass: \td.c = c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: e.d\n 75: Var Pass: \te.d = d\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: f.e\n 77: Var Pass: \tf.e = e\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: g.f\n 79: Var Pass: \tg.f = f\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: h.g\n 81: Var Pass: \th.g = g\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: i.h\n 83: Var Pass: \ti.h = h\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: j.i\n 85: Var Pass: \tj.i = i\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: k.j\n 87: Var Pass: \tk.j = j\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: l.k\n 89: Var Pass: \tl.k = k\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: m.l\n 91: Var Pass: \tm.l = l\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: n.m\n 93: Var Pass: \tn.m = m\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: o.n\n 95: Var Pass: \to.n = n\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: p.o\n 97: Var Pass: \tp.o = o\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: q.p\n 99: Var Pass: \tq.p = p\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_003_T/field_len_003_T.go\n AffectedNodeName: __taint_sink\n 100: SINK: \t__taint_sink(q.p.o.n.m.l.k.j.i.h.g.f.e.d.c.b.a.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_004_F/field_len_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\nLine 47: __taint_sink(q)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_src\n 54: SOURCE: field_len_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: field_len_005_T\n 54: CALL: field_len_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_src\n 31: ARG PASS: func field_len_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: pa\n 32: Var Pass: \tpa := A{\n 33: Var Pass: \t\tdata: __taint_src,\n 34: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: b.a\n 36: Var Pass: \tb.a = pa\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: c.b\n 38: Var Pass: \tc.b = b\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: d.c\n 40: Var Pass: \td.c = c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: e.d\n 42: Var Pass: \te.d = d\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: f.e\n 44: Var Pass: \tf.e = e\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: p\n 45: Var Pass: \tp := f.e.d.c\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: q\n 46: Var Pass: \tq := p.b.a.data\n /sast-go/cases/accuracy/field_sensitive/struct/field_len_005_T/field_len_005_T.go\n AffectedNodeName: __taint_sink\n 47: SINK: \t__taint_sink(q)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/field_len_006_F/field_len_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\nLine 22: __taint_sink(p.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: struct_field_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: struct_field_001_T\n 29: CALL: struct_field_001_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func struct_field_001_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: p\n 18: Var Pass: \tp := A{\n 19: Var Pass: \t\tdata: __taint_src,\n 20: Var Pass: \t\tsani: \"_\",\n 21: Var Pass: \t}\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_001_T/struct_field_001_T.go\n AffectedNodeName: __taint_sink\n 22: SINK: \t__taint_sink(p.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_002_F/struct_field_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\nLine 21: __taint_sink(p1.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: struct_field_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: struct_field_003_T\n 28: CALL: struct_field_003_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func struct_field_003_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: p1.data\n 19: Var Pass: \tp1.data = __taint_src\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_003_T/struct_field_003_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(p1.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_004_F/struct_field_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\nLine 19: __taint_sink(p1.string)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: struct_field_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: struct_field_005_T\n 26: CALL: struct_field_005_T(__taint_src)\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_field_005_T(__taint_src string) {\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: p1.string\n 18: Var Pass: \tp1.string = __taint_src\n /sast-go/cases/accuracy/field_sensitive/struct/struct_field_005_T/struct_field_005_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(p1.string)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/field_sensitive/struct/struct_field_006_F/struct_field_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/asynchronous/asynchronous_execution_001_T/asynchronous_execution_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/asynchronous/asynchronous_execution_002_F/asynchronous_execution_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/defer_exectution/defer_exectution_001_T/defer_exectution_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/defer_exectution/defer_exectution_002_F/defer_exectution_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_001_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: for_001_T\n 23: CALL: for_001_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_001_T(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_001_T/for_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_002_F(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: for_002_F\n 23: CALL: for_002_F(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_002_F(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_002_F/for_002_F.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_003_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: for_003_T\n 23: CALL: for_003_T(__taint_src)\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_003_T(__taint_src string) {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: res\n 15: Var Pass: \tfor res = __taint_src; i < 1; i++ {\n /sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_003_T/for_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/flow_sensitive/loop_stmt/for_004_F/for_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: array_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: array_obj_sensitive_001_T\n 23: CALL: array_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_001_T/array_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_002_F/array_obj_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: array_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: array_obj_sensitive_003_T\n 23: CALL: array_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_003_T/array_obj_sensitive_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_004_F/array_obj_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\nLine 16: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: array_obj_sensitive_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: array_obj_sensitive_007_T\n 22: CALL: array_obj_sensitive_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_obj_sensitive_007_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [...]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_007_T/array_obj_sensitive_007_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/array_obj_sensitive_008_F/array_obj_sensitive_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\nLine 17: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: map_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: map_obj_sensitive_001_T\n 24: CALL: map_obj_sensitive_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: m[\"key1\"]\n 15: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_001_T/map_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\nLine 15: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: map_obj_sensitive_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: map_obj_sensitive_002_T\n 22: CALL: map_obj_sensitive_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_002_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_002_T/map_obj_sensitive_002_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_003_F/map_obj_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\nLine 20: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: map_obj_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: map_obj_sensitive_004_T\n 27: CALL: map_obj_sensitive_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_obj_sensitive_004_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: m\n 13: Var Pass: \tm := map[string]string{\n 14: Var Pass: \t\t\"key1\": __taint_src,\n 15: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_004_T/map_obj_sensitive_004_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/map_obj_sensitive_005_F/map_obj_sensitive_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\nLine 18: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_001slice_obj_sensitive_001_T_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: slice_001slice_obj_sensitive_001_T_T\n 25: CALL: slice_001slice_obj_sensitive_001_T_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_001slice_obj_sensitive_001_T_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: arr\n 13: Var Pass: \tvar arr [3]string = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: s\n 17: Var Pass: \ts = arr[:]\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_001_T/slice_obj_sensitive_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_002_F/slice_obj_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\nLine 24: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: slice_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: slice_obj_sensitive_003_T\n 31: CALL: slice_obj_sensitive_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_obj_sensitive_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_003_T/slice_obj_sensitive_003_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/collection/slice_obj_sensitive_004_F/slice_obj_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_001_F/interface_class_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\nLine 41: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_src\n 48: SOURCE: interface_class_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: interface_class_002_T\n 48: CALL: interface_class_002_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_src\n 38: ARG PASS: func interface_class_002_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: process\n 40: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: process\n 40: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: res\n 40: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_002_T/interface_class_002_T.go\n AffectedNodeName: __taint_sink\n 41: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_003_F/interface_class_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\nLine 47: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_src\n 54: SOURCE: interface_class_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: interface_class_004_T\n 54: CALL: interface_class_004_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_src\n 44: ARG PASS: func interface_class_004_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: process\n 46: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: process\n 46: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: res\n 46: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_004_T/interface_class_004_T.go\n AffectedNodeName: __taint_sink\n 47: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_005_F/interface_class_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\nLine 39: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: interface_class_006_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: interface_class_006_T\n 46: CALL: interface_class_006_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_src\n 36: ARG PASS: func interface_class_006_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: process\n 38: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: process\n 38: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: res\n 38: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_006_T/interface_class_006_T.go\n AffectedNodeName: __taint_sink\n 39: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_007_F/interface_class_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\nLine 34: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_src\n 41: SOURCE: interface_class_008_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: interface_class_008_T\n 41: CALL: interface_class_008_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_src\n 31: ARG PASS: func interface_class_008_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: process\n 33: CALL: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: process\n 33: CALL RETURN: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: res\n 33: Var Pass: \tres := iTestService.process(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_008_T/interface_class_008_T.go\n AffectedNodeName: __taint_sink\n 34: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_009_F/interface_class_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_010_T/interface_class_010_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_011_F/interface_class_011_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\nLine 46: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\",\"functionName\":\"interface_class_012_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: __taint_src\n 43: SOURCE: func interface_class_012_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: processArg\n 45: CALL: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: processArg\n 45: CALL RETURN: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: res\n 45: Var Pass: \tres := processArg(iTestService, __taint_src)\n /sast-go/cases/accuracy/object_sensitive/interface_class/interface_class_012_T/interface_class_012_T.go\n AffectedNodeName: __taint_sink\n 46: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\nLine 24: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: struct_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: struct_007_T\n 31: CALL: struct_007_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_007_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{\n 18: Var Pass: \t\tdata: __taint_src,\n 19: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_007_T/struct_007_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_008_F/struct_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\nLine 57: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_src\n 65: SOURCE: struct_deep10_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: struct_deep10_001_T\n 65: CALL: struct_deep10_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_src\n 50: ARG PASS: func struct_deep10_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: obj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11\n 55: Var Pass: \tobj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_001_T/struct_deep10_001_T.go\n AffectedNodeName: __taint_sink\n 57: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\nLine 57: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_src\n 65: SOURCE: struct_deep10_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: struct_deep10_002_F\n 65: CALL: struct_deep10_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_src\n 50: ARG PASS: func struct_deep10_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: obj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11\n 55: Var Pass: \tobj1.deepA02.deepA03.deepA04.deepA05.deepA06.deepA07.deepA08.deepA09.deepA10.deepA11 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep10_002_F/struct_deep10_002_F.go\n AffectedNodeName: __taint_sink\n 57: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\nLine 31: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_src\n 39: SOURCE: struct_deep3_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: struct_deep3_001_T\n 39: CALL: struct_deep3_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: obj1.deepC02.deepC03.deepC04\n 29: Var Pass: \tobj1.deepC02.deepC03.deepC04 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_001_T/struct_deep3_001_T.go\n AffectedNodeName: __taint_sink\n 31: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\nLine 30: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_src\n 38: SOURCE: struct_deep3_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: struct_deep3_002_F\n 38: CALL: struct_deep3_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: obj1.deepC02.deepC03.deepC04\n 29: Var Pass: \tobj1.deepC02.deepC03.deepC04 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_002_F/struct_deep3_002_F.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\nLine 34: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_src\n 42: SOURCE: struct_deep3_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: struct_deep3_003_T\n 42: CALL: struct_deep3_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_src\n 24: ARG PASS: func struct_deep3_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: deepC03\n 29: Var Pass: \tdeepC03 := DeepC03{\n 30: Var Pass: \t\tdeepC04: __taint_src,\n 31: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: obj1.deepC02.deepC03\n 32: Var Pass: \tobj1.deepC02.deepC03 = deepC03\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_003_T/struct_deep3_003_T.go\n AffectedNodeName: __taint_sink\n 34: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep3_004_F/struct_deep3_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\nLine 35: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_src\n 43: SOURCE: struct_deep5_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: struct_deep5_001_T\n 43: CALL: struct_deep5_001_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_src\n 28: ARG PASS: func struct_deep5_001_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 33: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_001_T/struct_deep5_001_T.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\nLine 35: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_src\n 43: SOURCE: struct_deep5_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: struct_deep5_002_F\n 43: CALL: struct_deep5_002_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_src\n 28: ARG PASS: func struct_deep5_002_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 33: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = __taint_src\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_002_F/struct_deep5_002_F.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\nLine 42: __taint_sink(obj1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_src\n 50: SOURCE: struct_deep5_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: struct_deep5_003_T\n 50: CALL: struct_deep5_003_T(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_src\n 32: ARG PASS: func struct_deep5_003_T(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: deepB05\n 37: Var Pass: \tdeepB05 := DeepB05{\n 38: Var Pass: \t\tdeepB06: __taint_src,\n 39: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 40: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = deepB05\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_003_T/struct_deep5_003_T.go\n AffectedNodeName: __taint_sink\n 42: SINK: \t__taint_sink(obj1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\nLine 42: __taint_sink(obj2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_src\n 50: SOURCE: struct_deep5_004_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: struct_deep5_004_F\n 50: CALL: struct_deep5_004_F(__taint_src)\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_src\n 32: ARG PASS: func struct_deep5_004_F(__taint_src string) {\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: deepB05\n 37: Var Pass: \tdeepB05 := DeepB05{\n 38: Var Pass: \t\tdeepB06: __taint_src,\n 39: Var Pass: \t}\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: obj1.deepB02.deepB03.deepB04.deepB05\n 40: Var Pass: \tobj1.deepB02.deepB03.deepB04.deepB05 = deepB05\n /sast-go/cases/accuracy/object_sensitive/struct/struct_deep5_004_F/struct_deep5_004_F.go\n AffectedNodeName: __taint_sink\n 42: SINK: \t__taint_sink(obj2)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: break_003_T\n 25: CALL: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(res)\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: break_003_T\n 25: CALL: break_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: CALL: \t\t__taint_sink(res)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_003_T/break_003_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: break_004_F\n 26: CALL: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t\t__taint_sink(res)\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: break_004_F\n 26: CALL: break_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: CALL: \t\t__taint_sink(res)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_004_F/break_004_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: break_label_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: break_label_003_T\n 27: CALL: break_label_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_label_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_003_T/break_label_003_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_src\n 27: SOURCE: break_label_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: break_label_004_F\n 27: CALL: break_label_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func break_label_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/break_label_004_F/break_label_004_F.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: continue_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: continue_003_T\n 26: CALL: continue_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func continue_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_003_T/continue_003_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: continue_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: continue_004_F\n 26: CALL: continue_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func continue_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/continue_004_F/continue_004_F.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_003_T/fallthrough_003_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\nLine 24: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_src\n 30: SOURCE: fallthrough_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: fallthrough_004_F\n 30: CALL: fallthrough_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func fallthrough_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/fallthrough_004_F/fallthrough_004_F.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/goto_003_T/goto_003_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/goto_004_F/goto_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: return_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: return_003_T\n 23: CALL: return_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_003_T(__taint_src string) string {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_003_T/return_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_src\n 23: SOURCE: return_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: return_004_F\n 23: CALL: return_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_004_F(__taint_src string) string {\n /sast-go/cases/accuracy/path_sensitive/explicit_jump_control/return_004_F/return_004_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_src\n 24: SOURCE: conditional_if_005_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: conditional_if_005_F\n 24: CALL: conditional_if_005_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_005_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_005_F/conditional_if_005_F.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_006_F/conditional_if_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: conditional_if_007_T\n 25: CALL: conditional_if_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_007_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_007_T/conditional_if_007_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: conditional_if_008_F\n 25: CALL: conditional_if_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_008_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_008_F/conditional_if_008_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_003_F/conditional_switch_stmt_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_004_F/conditional_switch_stmt_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_005_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: conditional_switch_stmt_005_T\n 26: CALL: conditional_switch_stmt_005_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_005_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: res\n 18: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_005_T/conditional_switch_stmt_005_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_stmt_006_F/conditional_switch_stmt_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_009_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: conditional_if_009_T\n 25: CALL: conditional_if_009_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_009_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_009_T/conditional_if_009_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_010_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: conditional_if_010_F\n 25: CALL: conditional_if_010_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_010_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_010_F/conditional_if_010_F.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: conditional_switch_stmt_007_T\n 26: CALL: conditional_switch_stmt_007_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_007_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_007_T/conditional_switch_stmt_007_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_src\n 26: SOURCE: conditional_switch_stmt_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: conditional_switch_stmt_008_F\n 26: CALL: conditional_switch_stmt_008_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_stmt_008_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_stmt_008_F/conditional_switch_stmt_008_F.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: for_body_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: for_body_003_T\n 23: CALL: for_body_003_T(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_body_003_T(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: res\n 15: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_003_T/for_body_003_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_src\n 22: SOURCE: for_body_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: for_body_004_F\n 22: CALL: for_body_004_F(__taint_src)\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func for_body_004_F(__taint_src string) {\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: res\n 14: Var Pass: \t\tres = __taint_src\n /sast-go/cases/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_004_F/for_body_004_F.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\nLine 26: __taint_sink(s.Field(i))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: reflect_call_001_T\n 34: CALL: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 21: ARG PASS: func reflect_call_001_T(__taint_src string) {\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: t\n 22: Var Pass: \tt := T{123, __taint_src}\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: s\n 23: Var Pass: \ts := reflect.ValueOf(t)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(s.Field(i))\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\nLine 26: __taint_sink(s.Field(i))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 34: SOURCE: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: reflect_call_001_T\n 34: CALL: reflect_call_001_T(__taint_src)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_src\n 21: ARG PASS: func reflect_call_001_T(__taint_src string) {\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: t\n 22: Var Pass: \tt := T{123, __taint_src}\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: s\n 23: Var Pass: \ts := reflect.ValueOf(t)\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: CALL: \t\t__taint_sink(s.Field(i))\n /sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_001_T/reflect_call_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(s.Field(i))\n==========================================================\n #Total-findings:2\n==========================================================","/benchmarks/sast-go/cases/completeness/dynamic_tracing/reflect_call/reflect_call_002_F/reflect_call_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/alias/alias_001_F/alias_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\nLine 21: __taint_sink(a.Value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: alias_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: alias_002_T\n 28: CALL: alias_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func alias_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: b.Value\n 19: Var Pass: \tb.Value = __taint_src\n /sast-go/cases/completeness/single_app_tracing/alias/alias_002_T/alias_002_T.go\n AffectedNodeName: __taint_sink\n 21: SINK: \t__taint_sink(a.Value)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\nLine 17: __taint_sink(popch)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: asynchronous_goroutine_channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: asynchronous_goroutine_channel_001_T\n 24: CALL: asynchronous_goroutine_channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func asynchronous_goroutine_channel_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_001_T/asynchronous_goroutine_channel_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(<-ch)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_002_F/asynchronous_goroutine_channel_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\nLine 30: __taint_sink(message)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_src\n 40: SOURCE: asynchronous_goroutine_channel_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: asynchronous_goroutine_channel_003_T\n 40: CALL: asynchronous_goroutine_channel_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func asynchronous_goroutine_channel_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __single_module__.%dir_/.asynchronous_goroutine_channel_003_T.\n 27: CALL: \tgo func() {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __single_module__.%dir_/.asynchronous_goroutine_channel_003_T.\n 27: ARG PASS: \tgo func() {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_003_T/asynchronous_goroutine_channel_003_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t\t__taint_sink(message)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_goroutine_channel_004_F/asynchronous_goroutine_channel_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\nLine 33: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_src\n 45: SOURCE: asynchronous_multiple_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: asynchronous_multiple_select_001_T\n 45: CALL: asynchronous_multiple_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func asynchronous_multiple_select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: result\n 22: Var Pass: \t\tresult := __taint_src\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_001_T/asynchronous_multiple_select_001_T.go\n AffectedNodeName: __taint_sink\n 33: SINK: \t\t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_multiple_select_002_F/asynchronous_multiple_select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\nLine 26: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_src\n 36: SOURCE: asynchronous_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: asynchronous_select_001_T\n 36: CALL: asynchronous_select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_src\n 17: ARG PASS: func asynchronous_select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_001_T/asynchronous_select_001_T.go\n AffectedNodeName: __taint_sink\n 26: SINK: \t\t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/multi_thread/asynchronous_select_002_F/asynchronous_select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: synchronization_primitive_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: synchronization_primitive_001_T\n 22: CALL: synchronization_primitive_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func synchronization_primitive_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_001_T/synchronization_primitive_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_002_F/synchronization_primitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: synchronization_primitive_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: synchronization_primitive_003_T\n 25: CALL: synchronization_primitive_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func synchronization_primitive_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_003_T/synchronization_primitive_003_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/asynchronous_tracing/synchronization_primitive/synchronization_primitive_004_F/synchronization_primitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: conditional_if_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: conditional_if_001_T\n 21: CALL: conditional_if_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T/conditional_if_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F/conditional_if_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: conditional_if_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: conditional_if_003_T\n 25: CALL: conditional_if_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_if_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T/conditional_if_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_004_F/conditional_if_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\nLine 15: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: conditional_switch_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: conditional_switch_001_T\n 22: CALL: conditional_switch_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T/conditional_switch_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_002_F/conditional_switch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\nLine 16: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: conditional_switch_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: conditional_switch_003_T\n 23: CALL: conditional_switch_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: data\n 14: Var Pass: \tswitch data := __taint_src; data {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_003_T/conditional_switch_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t\t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_004_F/conditional_switch_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\nLine 22: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: conditional_switch_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: conditional_switch_005_T\n 30: CALL: conditional_switch_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func conditional_switch_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_005_T/conditional_switch_005_T.go\n AffectedNodeName: __taint_sink\n 22: SINK: \t\t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_006_F/conditional_switch_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: select_001_T\n 27: CALL: select_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func select_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_001_T/select_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/conditional_stmt/select_002_F/select_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: for_body_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: for_body_001_T\n 24: CALL: for_body_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_body_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: res\n 16: Var Pass: \t\tres = __taint_src\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T/for_body_001_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_body_002_F/for_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: for_init_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: for_init_001_T\n 25: CALL: for_init_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_init_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: ini\n 16: Var Pass: \tfor ini = __taint_src; j < 10; j++ {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = res + ini\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T/for_init_001_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_init_002_F/for_init_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: for_range_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: for_range_001_T\n 22: CALL: for_range_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_range_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: m\n 13: Var Pass: \tvar m = map[string]string{\"a\": __taint_src, \"b\": \"2\"}\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_001_T/for_range_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_range_002_F/for_range_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: for_update_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: for_update_001_T\n 26: CALL: for_update_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func for_update_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: j\n 16: Var Pass: \tfor ; ini < 2; j = __taint_src {\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: res\n 17: Var Pass: \t\tres = j\n /sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T/for_update_001_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(res)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/control_flow/loop_stmt/for_update_002_F/for_update_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: array_001_T\n 21: CALL: array_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_001_T/array_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_002_F/array_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: array_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: array_003_T\n 21: CALL: array_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [3][1]string{[1]string{__taint_src}, [1]string{\"b\"}, [1]string{\"c\"}}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_003_T/array_003_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_004_F/array_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: array_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: array_005_T\n 20: CALL: array_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_005_T(__taint_src [3]string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_005_T/array_005_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_006_F/array_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: array_007_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: array_007_T\n 20: CALL: array_007_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func array_007_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: str\n 13: Var Pass: \tvar str = [...]string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/array/array_007_T/array_007_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(str)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/array/array_008_F/array_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\nLine 16: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: generics_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: generics_001_T\n 23: CALL: generics_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_src\n 14: ARG PASS: func generics_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: s\n 15: Var Pass: \tvar s Slice[string] = []string{\"a\", \"b\", __taint_src}\n /sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_001_T/generics_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/generics/generics_002_F/generics_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\nLine 15: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: map_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: map_001_T\n 22: CALL: map_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: m[\"key1\"]\n 14: Var Pass: \tm[\"key1\"] = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_001_T/map_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_002_F/map_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\nLine 16: __taint_sink(m)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: map_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: map_003_T\n 23: CALL: map_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func map_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: m\n 13: Var Pass: \tm := map[string]string{\n 14: Var Pass: \t\t\"key1\": __taint_src,\n 15: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/map/map_003_T/map_003_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(m)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/map/map_004_F/map_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\nLine 14: __taint_sink(*ps)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: pointer_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: pointer_001_T\n 21: CALL: pointer_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func pointer_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: ps\n 13: Var Pass: \tps := &__taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_001_T/pointer_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(*ps)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_002_F/pointer_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\nLine 16: __taint_sink(*ps)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: pointer_new_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: pointer_new_001_T\n 23: CALL: pointer_new_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func pointer_new_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n 15: Var Pass: \t*ps = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_001_T/pointer_new_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(*ps)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/pointer/pointer_new_002_F/pointer_new_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_src\n 19: SOURCE: primitives_bool_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: primitives_bool_001_T\n 19: CALL: primitives_bool_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_bool_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_001_T/primitives_bool_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_bool_002_F/primitives_bool_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_complex_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: primitives_complex_001_T\n 20: CALL: primitives_complex_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_complex_001_T(__taint_src complex64) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_001_T/primitives_complex_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_complex_002_F/primitives_complex_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_float_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: primitives_float_001_T\n 20: CALL: primitives_float_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_float_001_T(__taint_src float64) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_001_T/primitives_float_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_float_002_F/primitives_float_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: primitives_int_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: primitives_int_001_T\n 20: CALL: primitives_int_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func primitives_int_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_001_T/primitives_int_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/primitives/primitives_int_002_F/primitives_int_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: slice_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: slice_001_T\n 20: CALL: slice_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: s\n 13: Var Pass: \tvar s []string = []string{__taint_src, \"b\", \"c\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_001_T/slice_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_002_F/slice_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\nLine 15: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: slice_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: slice_003_T\n 22: CALL: slice_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: s\n 14: Var Pass: \ts = append(s, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_003_T/slice_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_004_F/slice_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\nLine 18: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: slice_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: slice_005_T\n 25: CALL: slice_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func slice_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: s\n 13: Var Pass: \ts := [][]string{\n 14: Var Pass: \t\t[]string{\"a\"},\n 15: Var Pass: \t\t[]string{\"b\", \"c\"},\n 16: Var Pass: \t\t[]string{\"d\", \"e\", __taint_src},\n 17: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_005_T/slice_005_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(s)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_006_F/slice_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_007_T/slice_007_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/slice/slice_008_F/slice_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\nLine 17: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: channel_001_T\n 23: CALL: channel_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func channel_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_001_T/channel_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(c)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/specialtype/channel_002_F/channel_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: string_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: string_001_T\n 20: CALL: string_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func string_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/string/string_001_T/string_001_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/string/string_002_F/string_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\nLine 30: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: complex_struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: complex_struct_001_T\n 37: CALL: complex_struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_src\n 13: ARG PASS: func complex_struct_001_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: Say\n 16: CALL: \ta.b.Say(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: c\n 29: ARG PASS: func (b B) Say(c interface{}) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_001_T/complex_struct_001_T.go\n AffectedNodeName: __taint_sink\n 30: SINK: \t__taint_sink(c)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/complex_struct_002_F/complex_struct_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\nLine 20: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: struct_001_T\n 27: CALL: struct_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{\n 18: Var Pass: \t\tdata: __taint_src,\n 19: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_001_T/struct_001_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_002_F/struct_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\nLine 19: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: struct_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: struct_003_T\n 26: CALL: struct_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: p.data\n 18: Var Pass: \tp.data = __taint_src\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_003_T/struct_003_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_004_F/struct_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\nLine 18: __taint_sink(p.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: struct_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: struct_005_T\n 24: CALL: struct_005_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func struct_005_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: p\n 17: Var Pass: \tp := A{__taint_src}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_005_T/struct_005_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t__taint_sink(p.data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_006_F/struct_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\nLine 25: __taint_sink(pb)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_src\n 32: SOURCE: struct_cross_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: struct_cross_001_T\n 32: CALL: struct_cross_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_src\n 19: ARG PASS: func struct_cross_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: pa\n 20: Var Pass: \tpa := A{\n 21: Var Pass: \t\tdata: __taint_src,\n 22: Var Pass: \t}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: pb.data\n 24: Var Pass: \tpb.data = pa.data\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_001_T/struct_cross_001_T.go\n AffectedNodeName: __taint_sink\n 25: SINK: \t__taint_sink(pb)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_002_F/struct_cross_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\nLine 24: __taint_sink(p)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_src\n 30: SOURCE: struct_cross_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: struct_cross_003_T\n 30: CALL: struct_cross_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_src\n 20: ARG PASS: func struct_cross_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: p\n 21: Var Pass: \tp := B{A{\n 22: Var Pass: \t\tdata: __taint_src,\n 23: Var Pass: \t}, \"_\"}\n /sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_003_T/struct_cross_003_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(p)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/datatype/struct/struct_cross_004_F/struct_cross_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/exception_error/exception_throw/exception_throw_001_T/exception_throw_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/exception_error/exception_throw/exception_throw_002_F/exception_throw_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: assign_expression_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: assign_expression_001_T\n 20: CALL: assign_expression_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func assign_expression_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T/assign_expression_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_002_F/assign_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: binary_expression_add_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: binary_expression_add_001_T\n 20: CALL: binary_expression_add_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func binary_expression_add_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src + \"_\"\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T/binary_expression_add_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_002_F/binary_expression_add_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: binary_expression_add_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: binary_expression_add_assignment_001_T\n 21: CALL: binary_expression_add_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func binary_expression_add_assignment_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T/binary_expression_add_assignment_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_002_F/binary_expression_add_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: bitwise_expression_and_001_T\n 20: CALL: bitwise_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_and_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src & 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T/bitwise_expression_and_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_002_F/bitwise_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_lsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: bitwise_expression_lsh_001_T\n 20: CALL: bitwise_expression_lsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_lsh_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src << 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T/bitwise_expression_lsh_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_002_F/bitwise_expression_lsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_not_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: bitwise_expression_not_001_T\n 20: CALL: bitwise_expression_not_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_not_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T/bitwise_expression_not_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_002_F/bitwise_expression_not_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: bitwise_expression_or_001_T\n 20: CALL: bitwise_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_or_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src | 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T/bitwise_expression_or_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_002_F/bitwise_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: bitwise_expression_rsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: bitwise_expression_rsh_001_T\n 20: CALL: bitwise_expression_rsh_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_rsh_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src >> 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T/bitwise_expression_rsh_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_002_F/bitwise_expression_rsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: bitwise_expression_xor_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: bitwise_expression_xor_001_T\n 21: CALL: bitwise_expression_xor_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func bitwise_expression_xor_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src ^ 1\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T/bitwise_expression_xor_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_002_F/bitwise_expression_xor_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: logic_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: logic_expression_and_001_T\n 20: CALL: logic_expression_and_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func logic_expression_and_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src && true\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_T/logic_expression_and_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_F/logic_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 20: SOURCE: logic_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: logic_expression_or_001_T\n 20: CALL: logic_expression_or_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func logic_expression_or_001_T(__taint_src bool) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := false || __taint_src\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T/logic_expression_or_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_002_F/logic_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: relation_expression_equal_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: relation_expression_equal_001_T\n 21: CALL: relation_expression_equal_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func relation_expression_equal_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := __taint_src == \"__taint_src\"\n /sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T/relation_expression_equal_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F/relation_expression_equal_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\nLine 14: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: blank_identifier_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: blank_identifier_001_T\n 25: CALL: blank_identifier_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func blank_identifier_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: getData\n 13: CALL: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: getData\n 13: CALL RETURN: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n 13: Var Pass: \ta, _ := getData(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_001_T/blank_identifier_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(a)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/blank_identifier_002_F/blank_identifier_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: multiple_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: multiple_assignment_001_T\n 21: CALL: multiple_assignment_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_assignment_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_001_T/multiple_assignment_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/multiple_assignment_002_F/multiple_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\nLine 17: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: rest_parameter_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: rest_parameter_001_T\n 24: CALL: rest_parameter_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func rest_parameter_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: collectArgs\n 13: CALL: \tcollectArgs(\"prefix\", __taint_src, \"suffix\")\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: args\n 16: ARG PASS: func collectArgs(args ...interface{}) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T/rest_parameter_001_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(args)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/rest_parameter_002_F/rest_parameter_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\nLine 15: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: spread_operator_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: spread_operator_001_T\n 22: CALL: spread_operator_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func spread_operator_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: array1\n 13: Var Pass: \tarray1 := []string{\"a\", \"b\", __taint_src}\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: array\n 14: Var Pass: \tarray := append([]string{\"c\"}, array1...)\n /sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T/spread_operator_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(array)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/special_expression/spread_operator_002_F/spread_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_src\n 21: SOURCE: type_cast_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: type_cast_001_T\n 21: CALL: type_cast_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func type_cast_001_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := float64(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_001_T/type_cast_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_002_F/type_cast_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: type_cast_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: type_cast_003_T\n 22: CALL: type_cast_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func type_cast_003_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n 13: Var Pass: \tresult, ok := __taint_src.(string)\n /sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_003_T/type_cast_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/expression/type_cast/type_cast_004_F/type_cast_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_001_F/anonymous_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\nLine 16: __taint_sink(process(__taint_src, \"foo\"))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: anonymous_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: anonymous_function_002_T\n 23: CALL: anonymous_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn a + b\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: \n 16: CALL RETURN: \t__taint_sink(process(__taint_src, \"foo\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T/anonymous_function_002_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(process(__taint_src, \"foo\"))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_003_F/anonymous_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\nLine 15: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: anonymous_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: anonymous_function_004_T\n 25: CALL: anonymous_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: \n 18: CALL: \tprocess(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: input\n 14: ARG PASS: \tprocess := func(input interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T/anonymous_function_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t__taint_sink(input)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_005_F/anonymous_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_src\n 22: SOURCE: anonymous_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: anonymous_function_006_T\n 22: CALL: anonymous_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func anonymous_function_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __single_module__.%dir_/.anonymous_function_006_T.\n 13: CALL: \tfunc() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __single_module__.%dir_/.anonymous_function_006_T.\n 13: ARG PASS: \tfunc() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T/anonymous_function_006_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_001_F/closure_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: closure_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: closure_function_002_T\n 23: CALL: closure_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_002_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_002_T.\n 17: CALL: \tclosure()\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_002_T.\n 13: ARG PASS: \tclosure := func() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T/closure_function_002_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_003_F/closure_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\nLine 15: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_src\n 26: SOURCE: closure_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: closure_function_004_T\n 26: CALL: closure_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_004_T..\n 20: CALL: \tclosure_function_004_Function()\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_004_T..\n 14: ARG PASS: \t\treturn func() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T/closure_function_004_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t\t__taint_sink(__taint_src)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_005_F/closure_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\nLine 35: __taint_sink(a.update())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_src\n 42: SOURCE: closure_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: closure_function_006_T\n 42: CALL: closure_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_src\n 13: ARG PASS: func closure_function_006_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: source\n 25: Var Pass: \t\t\t\tsource = __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: [return value]\n 26: Return Value: \t\t\t\treturn source\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: \n 35: CALL RETURN: \t__taint_sink(a.update())\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_T/closure_function_006_T.go\n AffectedNodeName: __taint_sink\n 35: SINK: \t__taint_sink(a.update())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_F/closure_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\nLine 20: __taint_sink(middleVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_src\n 38: SOURCE: closure_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: closure_function_008_T\n 38: CALL: closure_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_008_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: outerVar\n 14: Var Pass: \t\touterVar := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: middleVar\n 17: Var Pass: \t\t\tmiddleVar := outerVar\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_008_T...\n 31: CALL: \tclosure_function_008_Tunction()\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_008_T...\n 19: ARG PASS: \t\t\tinner := func() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_T/closure_function_008_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t\t\t\t__taint_sink(middleVar)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_F/closure_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\nLine 18: __taint_sink(outerVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_src\n 36: SOURCE: closure_function_010_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: closure_function_010_T\n 36: CALL: closure_function_010_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func closure_function_010_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: outerVar\n 14: Var Pass: \t\touterVar := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_010_T...\n 29: CALL: \tclosure_function_010_Tunction()\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __single_module__.%dir_/.closure_function_010_T...\n 17: ARG PASS: \t\t\tinner := func() {\n /sast-go/cases/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_T/closure_function_010_T.go\n AffectedNodeName: __taint_sink\n 18: SINK: \t\t\t\t__taint_sink(outerVar)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_001_F/argument_passing_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\nLine 17: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_src\n 24: SOURCE: argument_passing_value_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: argument_passing_value_002_T\n 24: CALL: argument_passing_value_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: process\n 13: CALL: \tprocess(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: arg\n 16: ARG PASS: func process(arg string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_002_T/argument_passing_value_002_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_003_F/argument_passing_value_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\nLine 19: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: argument_passing_value_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: argument_passing_value_004_T\n 29: CALL: argument_passing_value_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: process1\n 15: CALL: \tprocess1(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: arg\n 18: ARG PASS: func process1(arg interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_004_T/argument_passing_value_004_T.go\n AffectedNodeName: __taint_sink\n 19: SINK: \t__taint_sink(arg)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_005_F/argument_passing_value_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\nLine 17: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_src\n 23: SOURCE: argument_passing_value_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: argument_passing_value_006_T\n 23: CALL: argument_passing_value_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_006_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: process\n 13: CALL: \tprocess(__taint_src, \"_\")\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: arg1\n 16: ARG PASS: func process(arg1 string, arg2 string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_006_T/argument_passing_value_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(arg1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_007_F/argument_passing_value_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\nLine 15: __taint_sink(innerInput)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: argument_passing_value_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: argument_passing_value_008_T\n 27: CALL: argument_passing_value_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func argument_passing_value_008_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: \n 21: CALL: \touter(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: input\n 13: ARG PASS: \touter := func(input string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: \n 18: CALL: \t\tinner(input)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: innerInput\n 14: ARG PASS: \t\tinner := func(innerInput interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_008_T/argument_passing_value_008_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t\t\t__taint_sink(innerInput)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\nLine 20: __taint_sink(person.GetNamePointer())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_src\n 35: SOURCE: argument_passing_value_009_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: argument_passing_value_009_T\n 35: CALL: argument_passing_value_009_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_src\n 16: ARG PASS: func argument_passing_value_009_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: person\n 17: Var Pass: \tperson := Person{Name: __taint_src}\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: GetNamePointer\n 20: CALL RETURN: \t__taint_sink(person.GetNamePointer())\n /sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_009_T/argument_passing_value_009_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(person.GetNamePointer())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/argument_passing/argument_passing_value_010_F/argument_passing_value_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_001_F/chained_call_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\nLine 31: __taint_sink(a.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: chained_call_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: chained_call_002_T\n 37: CALL: chained_call_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func chained_call_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: setName\n 13: CALL: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: setName\n 13: CALL RETURN: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: process\n 13: CALL: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: new A().setName(\"_\").clearName().setName(__taint_s\n 13: ARG PASS: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: process\n 13: CALL: \tnew(A).setName(\"_\").clearName().setName(__taint_src).process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: process\n 30: ARG PASS: func (a *A) process() {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T/chained_call_002_T.go\n AffectedNodeName: __taint_sink\n 31: SINK: \t__taint_sink(a.name)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_003_F/chained_call_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\nLine 39: __taint_sink(b.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: chained_call_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: chained_call_004_T\n 46: CALL: chained_call_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func chained_call_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetName\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetName\n 13: CALL RETURN: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetOther\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: NewB().SetName(__taint_src)\n 13: ARG PASS: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: SetOther\n 13: CALL RETURN: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: Process\n 13: CALL: \tNewB().SetName(__taint_src).SetOther().Process()\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: Process\n 38: ARG PASS: func (b *B) Process() {\n /sast-go/cases/completeness/single_app_tracing/function_call/chained_call/chained_call_004_T/chained_call_004_T.go\n AffectedNodeName: __taint_sink\n 39: SINK: \t__taint_sink(b.name)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_001_F/higher_order_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\nLine 20: __taint_sink(f(__taint_src, \"_\")())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: higher_order_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: higher_order_function_002_T\n 27: CALL: higher_order_function_002_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_002_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: [return value]\n 16: Return Value: \t\t\treturn a + b + c\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: \n 20: CALL RETURN: \t__taint_sink(f(__taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T/higher_order_function_002_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(f(__taint_src, \"_\")())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_003_F/higher_order_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\nLine 24: __taint_sink(f(g, __taint_src, \"_\"))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_src\n 31: SOURCE: higher_order_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: higher_order_function_004_T\n 31: CALL: higher_order_function_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: [return value]\n 20: Return Value: \t\t\treturn a + b + c\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 14: CALL RETURN: \t\treturn g(a, b)()\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn g(a, b)()\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: \n 24: CALL RETURN: \t__taint_sink(f(g, __taint_src, \"_\"))\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T/higher_order_function_004_T.go\n AffectedNodeName: __taint_sink\n 24: SINK: \t__taint_sink(f(g, __taint_src, \"_\"))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_005_F/higher_order_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\nLine 13: __taint_sink(f(g, u, __taint_src, \"_\")())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_src\n 35: SOURCE: higher_order_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: higher_order_function_006_T\n 35: CALL: higher_order_function_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: f\n 13: CALL: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: \n 13: CALL RETURN: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T/higher_order_function_006_T.go\n AffectedNodeName: __taint_sink\n 13: SINK: \t__taint_sink(f(g, u, __taint_src, \"_\")())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_007_F/higher_order_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: higher_order_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: higher_order_function_008_T\n 27: CALL: higher_order_function_008_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func higher_order_function_008_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: [return value]\n 14: Return Value: \t\treturn a + b\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: higher_order_function_008_Function\n 13: CALL RETURN: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n 14: CALL RETURN: \t\treturn a + b\n 15: CALL RETURN: \t}, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: result\n 13: Var Pass: \tresult := higher_order_function_008_Function(func(a string, b string) string {\n 14: Var Pass: \t\treturn a + b\n 15: Var Pass: \t}, __taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T/higher_order_function_008_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_arg_001_T/arg_arg_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_arg_002_F/arg_arg_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_src\n 28: SOURCE: arg_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: arg_return_001_T\n 28: CALL: arg_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func arg_return_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: taintedData\n 13: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: appendTaint\n 15: CALL: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: appendTaint\n 15: CALL RETURN: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: result\n 15: Var Pass: \tresult := appendTaint(sList, taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_001_T/arg_return_001_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_002_F/arg_return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_src\n 29: SOURCE: arg_return_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: arg_return_003_T\n 29: CALL: arg_return_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_src\n 14: ARG PASS: func arg_return_003_T(__taint_src int) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: taintedData\n 15: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: itoaTaint\n 16: CALL: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: itoaTaint\n 16: CALL RETURN: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: result\n 16: Var Pass: \tresult := itoaTaint(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_003_T/arg_return_003_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/arg_return_004_F/arg_return_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: this_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: this_return_001_T\n 27: CALL: this_return_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func this_return_001_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintedData\n 13: Var Pass: \ttaintedData := __taint_src\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintToString\n 14: CALL: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: taintToString\n 14: CALL RETURN: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: result\n 14: Var Pass: \tresult := taintToString(taintedData)\n /sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_001_T/this_return_001_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/library_function/this_return_002_F/this_return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\nLine 14: __taint_sink(sub.call(__taint_src))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_src\n 37: SOURCE: polymorphism_override_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: polymorphism_override_001_T\n 37: CALL: polymorphism_override_001_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_override_001_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: call\n 14: CALL: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: call\n 14: CALL RETURN: \t__taint_sink(sub.call(__taint_src))\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T/polymorphism_override_001_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(sub.call(__taint_src))\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_002_F/polymorphism_override_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\nLine 15: __taint_sink(student.Run())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_src\n 46: SOURCE: polymorphism_override_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: polymorphism_override_003_T\n 46: CALL: polymorphism_override_003_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func polymorphism_override_003_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: student\n 12: Var Pass: \tvar student Person = &Student{Name: __taint_src, Age: 20, GPA: 3.8}\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: Run\n 15: CALL RETURN: \t__taint_sink(student.Run())\n /sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_003_T/polymorphism_override_003_T.go\n AffectedNodeName: __taint_sink\n 15: SINK: \t__taint_sink(student.Run())\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/override/polymorphism_override_004_F/polymorphism_override_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_005_F/multiple_return_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\nLine 17: __taint_sink(ret1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: multiple_return_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: multiple_return_006_T\n 27: CALL: multiple_return_006_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func multiple_return_006_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: processData\n 15: CALL: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n 15: Var Pass: \tret1, ret2 := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/multiple_return_006_T/multiple_return_006_T.go\n AffectedNodeName: __taint_sink\n 17: SINK: \t__taint_sink(ret1)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_003_F/named_return_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\nLine 16: __taint_sink(ret)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_src\n 27: SOURCE: named_return_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: named_return_004_T\n 27: CALL: named_return_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func named_return_004_T(__taint_src interface{}) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: processData\n 15: CALL: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: processData\n 15: CALL RETURN: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: ret\n 15: Var Pass: \tret := processData(__taint_src, a)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/named_return_004_T/named_return_004_T.go\n AffectedNodeName: __taint_sink\n 16: SINK: \t__taint_sink(ret)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_003_F/return_value_passing_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\nLine 14: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_src\n 25: SOURCE: return_value_passing_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: return_value_passing_004_T\n 25: CALL: return_value_passing_004_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_src\n 12: ARG PASS: func return_value_passing_004_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: process\n 13: CALL: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: process\n 13: CALL RETURN: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: data\n 13: Var Pass: \tdata := process(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/function_call/return_value_passing/return_value_passing_004_T/return_value_passing_004_T.go\n AffectedNodeName: __taint_sink\n 14: SINK: \t__taint_sink(data)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\",\"functionName\":\"main\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_src\n 58: SOURCE: interface_class_001_c_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: interface_class_001_c_T\n 58: CALL: interface_class_001_c_T(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_src\n 11: ARG PASS: func interface_class_001_c_T(__taint_src string) {\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: GetTest\n 19: CALL: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: GetTest\n 19: CALL RETURN: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n 19: Var Pass: \tresult, _ := testAPI.GetTest(__taint_src)\n /sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_001_c_T/interface_class_001_c_T.go\n AffectedNodeName: __taint_sink\n 20: SINK: \t__taint_sink(result)\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-go/cases/completeness/single_app_tracing/interface_class/interface_implementation/interface_class_002_c_F/interface_class_002_c_F":"======================== Findings ========================\nNo findings!\n=========================================================="} \ No newline at end of file diff --git a/test/java/expect/sast-java-expect.result b/test/java/expect/sast-java-expect.result index 95390b87..8d28400e 100644 --- a/test/java/expect/sast-java-expect.result +++ b/test/java/expect/sast-java-expect.result @@ -191,12 +191,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_001_T.java AffectedNodeName: set 32: CALL: a.obj.set(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_001_T.java - AffectedNodeName: get - 33: CALL: String s = a.get(); // tainted - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_001_T.java - AffectedNodeName: a - 33: ARG PASS: String s = a.get(); // tainted /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_001_T.java AffectedNodeName: get 33: CALL RETURN: String s = a.get(); // tainted @@ -222,12 +216,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_005_T.java AffectedNodeName: set 32: CALL: a.obj.set(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_005_T.java - AffectedNodeName: get - 33: CALL: String s = a.obj.get(); // tainted - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_005_T.java - AffectedNodeName: a.obj - 33: ARG PASS: String s = a.obj.get(); // tainted /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_005_T.java AffectedNodeName: get 33: CALL RETURN: String s = a.obj.get(); // tainted @@ -278,12 +266,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_007_T.java AffectedNodeName: set 32: CALL: a.obj2.foo.set(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_007_T.java - AffectedNodeName: get - 33: CALL: String s = b.get(); // tainted - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_007_T.java - AffectedNodeName: b - 33: ARG PASS: String s = b.get(); // tainted /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/alias/InnerClassAlias_007_T.java AffectedNodeName: get 33: CALL RETURN: String s = b.get(); // tainted @@ -545,18 +527,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java AffectedNodeName: setCmd 27: CALL: simpleBean.setCmd(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java - AffectedNodeName: setCmd2 - 28: CALL: simpleBean.setCmd2("cd /"); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java - AffectedNodeName: simpleBean - 28: ARG PASS: simpleBean.setCmd2("cd /"); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java - AffectedNodeName: getCmd - 29: CALL: Runtime.getRuntime().exec(simpleBean.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java - AffectedNodeName: simpleBean - 29: ARG PASS: Runtime.getRuntime().exec(simpleBean.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_interface_class/PropertyIsTaintOrNot_Object_001_T.java AffectedNodeName: getCmd 29: CALL RETURN: Runtime.getRuntime().exec(simpleBean.getCmd()); @@ -620,7 +590,7 @@ Trace: AffectedNodeName: doGet 65: CALL: return doGet(url, null); /src/main/java/com/sast/astbenchmark/common/utils/HttpUtil.java - AffectedNodeName: url + AffectedNodeName: doGet 22: ARG PASS: public static String doGet(String url, Map param) throws Exception { /src/main/java/com/sast/astbenchmark/common/utils/HttpUtil.java AffectedNodeName: builder @@ -751,12 +721,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/object_sensitive/ObjectDiffAttribute_001_T.java AffectedNodeName: setCmd 28: CALL: a.setCmd(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/object_sensitive/ObjectDiffAttribute_001_T.java - AffectedNodeName: getCmd - 30: CALL: Runtime.getRuntime().exec(a.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/object_sensitive/ObjectDiffAttribute_001_T.java - AffectedNodeName: a - 30: ARG PASS: Runtime.getRuntime().exec(a.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/object_sensitive/ObjectDiffAttribute_001_T.java AffectedNodeName: getCmd 30: CALL RETURN: Runtime.getRuntime().exec(a.getCmd()); @@ -919,12 +883,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/context_sensitive/polymorphism/Expression_Polymorphism_001_T.java AffectedNodeName: ps 27: Var Pass: PS ps = new PS(cmd, "~"); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/context_sensitive/polymorphism/Expression_Polymorphism_001_T.java - AffectedNodeName: getCmd - 28: CALL: Runtime.getRuntime().exec(ps.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/context_sensitive/polymorphism/Expression_Polymorphism_001_T.java - AffectedNodeName: ps - 28: ARG PASS: Runtime.getRuntime().exec(ps.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/context_sensitive/polymorphism/Expression_Polymorphism_001_T.java AffectedNodeName: getCmd 28: CALL RETURN: Runtime.getRuntime().exec(ps.getCmd()); @@ -956,6 +914,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_001_T.java AffectedNodeName: t 25: ARG PASS: t.start(); + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_001_T.java + AffectedNodeName: run + 25: CALL: t.start(); + /src/main/java/com/sast/astbenchmark/model/custom/T.java + AffectedNodeName: run + 14: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/T.java AffectedNodeName: Runtime.getRuntime().exec 16: SINK: Runtime.getRuntime().exec(this.cmd); @@ -972,6 +936,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_003_T.java AffectedNodeName: cmd 24: SOURCE: public Map testcase(@RequestParam String cmd) { + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_003_T.java + AffectedNodeName: run + 26: CALL: new Thread(new Runnable() { + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_003_T.java + AffectedNodeName: run + 28: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_003_T.java AffectedNodeName: Runtime.getRuntime().exec 30: SINK: Runtime.getRuntime().exec(cmd); @@ -1000,6 +970,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_005_T.java AffectedNodeName: Executors.newCachedThreadPool() 26: ARG PASS: Executors.newCachedThreadPool().execute(r); + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_005_T.java + AffectedNodeName: run + 26: CALL: Executors.newCachedThreadPool().execute(r); + /src/main/java/com/sast/astbenchmark/model/custom/R.java + AffectedNodeName: run + 14: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/R.java AffectedNodeName: Runtime.getRuntime().exec 16: SINK: Runtime.getRuntime().exec(this.cmd); @@ -1028,6 +1004,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_007_T.java AffectedNodeName: timer 27: ARG PASS: timer.schedule(tt, 2000); + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_007_T.java + AffectedNodeName: run + 27: CALL: timer.schedule(tt, 2000); + /src/main/java/com/sast/astbenchmark/model/custom/TT.java + AffectedNodeName: run + 16: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/TT.java AffectedNodeName: Runtime.getRuntime().exec 18: SINK: Runtime.getRuntime().exec(this.cmd); @@ -1047,6 +1029,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_009_T.java AffectedNodeName: obj.a 32: Var Pass: obj.a = cmd; + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_009_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.flow_sensitive.asynchronous.Async_Multithread_009_T.testcase. + 36: CALL: Thread thread2 = new Thread(() -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_009_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.flow_sensitive.asynchronous.Async_Multithread_009_T.testcase. + 36: ARG PASS: Thread thread2 = new Thread(() -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/asynchronous/Async_Multithread_009_T.java AffectedNodeName: Runtime.getRuntime().exec 39: SINK: Runtime.getRuntime().exec(obj.a); @@ -1088,12 +1076,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/normal_stmt/AssignObjectAttribute_002_T.java AffectedNodeName: setCmd 29: CALL: b.setCmd(a); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/normal_stmt/AssignObjectAttribute_002_T.java - AffectedNodeName: getCmd - 31: CALL: Runtime.getRuntime().exec(b.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/normal_stmt/AssignObjectAttribute_002_T.java - AffectedNodeName: b - 31: ARG PASS: Runtime.getRuntime().exec(b.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/flow_sensitive/normal_stmt/AssignObjectAttribute_002_T.java AffectedNodeName: getCmd 31: CALL RETURN: Runtime.getRuntime().exec(b.getCmd()); @@ -1703,12 +1685,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_001_T.java AffectedNodeName: a 27: Var Pass: G a = new G<>(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_001_T.java - AffectedNodeName: getCmd - 28: CALL: Runtime.getRuntime().exec(a.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_001_T.java - AffectedNodeName: a - 28: ARG PASS: Runtime.getRuntime().exec(a.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_001_T.java AffectedNodeName: getCmd 28: CALL RETURN: Runtime.getRuntime().exec(a.getCmd()); @@ -1734,12 +1710,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_003_T.java AffectedNodeName: a 26: Var Pass: G a = new G<>(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_003_T.java - AffectedNodeName: getCmd - 28: CALL: Runtime.getRuntime().exec((String) a.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_003_T.java - AffectedNodeName: a - 28: ARG PASS: Runtime.getRuntime().exec((String) a.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/datatype/generics/CallExpression_CustomCode_Class_generics_003_T.java AffectedNodeName: getCmd 28: CALL RETURN: Runtime.getRuntime().exec((String) a.getCmd()); @@ -2270,12 +2240,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/anonymous_object/CallExpression_CustomCode_anonymous_object_001_T.java AffectedNodeName: setCmd 34: CALL: ac.setCmd(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/anonymous_object/CallExpression_CustomCode_anonymous_object_001_T.java - AffectedNodeName: getCmd - 35: CALL: Runtime.getRuntime().exec(ac.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/anonymous_object/CallExpression_CustomCode_anonymous_object_001_T.java - AffectedNodeName: ac - 35: ARG PASS: Runtime.getRuntime().exec(ac.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/anonymous_object/CallExpression_CustomCode_anonymous_object_001_T.java AffectedNodeName: [return value] 31: Return Value: return this.cmd; @@ -2304,12 +2268,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Class_001_T.java AffectedNodeName: a 26: Var Pass: O a = new O(cmd); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Class_001_T.java - AffectedNodeName: getCmd - 28: CALL: Runtime.getRuntime().exec(a.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Class_001_T.java - AffectedNodeName: a - 28: ARG PASS: Runtime.getRuntime().exec(a.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Class_001_T.java AffectedNodeName: getCmd 28: CALL RETURN: Runtime.getRuntime().exec(a.getCmd()); @@ -2351,12 +2309,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Interface_001_T.java AffectedNodeName: cmd 24: SOURCE: public Map testcase(@PathVariable String cmd) { - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Interface_001_T.java - AffectedNodeName: - 28: CALL: Runtime.getRuntime().exec(s.getCmd("ls", cmd)); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Interface_001_T.java - AffectedNodeName: b - 27: ARG PASS: Inter s = (Serializable & Inter) (a, b) -> a + b; /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/interface_class/complex_object/CallExpression_CustomCode_Interface_001_T.java AffectedNodeName: 28: CALL RETURN: Runtime.getRuntime().exec(s.getCmd("ls", cmd)); @@ -2429,6 +2381,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_001_T.java AffectedNodeName: t 25: ARG PASS: t.start(); + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_001_T.java + AffectedNodeName: run + 25: CALL: t.start(); + /src/main/java/com/sast/astbenchmark/model/custom/T.java + AffectedNodeName: run + 14: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/T.java AffectedNodeName: Runtime.getRuntime().exec 16: SINK: Runtime.getRuntime().exec(this.cmd); @@ -2445,6 +2403,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_003_T.java AffectedNodeName: cmd 24: SOURCE: public Map testcase(@RequestParam String cmd) { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_003_T.java + AffectedNodeName: run + 26: CALL: new Thread(new Runnable() { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_003_T.java + AffectedNodeName: run + 28: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_003_T.java AffectedNodeName: Runtime.getRuntime().exec 30: SINK: Runtime.getRuntime().exec(cmd); @@ -2473,6 +2437,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_005_T.java AffectedNodeName: Executors.newCachedThreadPool() 26: ARG PASS: Executors.newCachedThreadPool().execute(r); + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_005_T.java + AffectedNodeName: run + 26: CALL: Executors.newCachedThreadPool().execute(r); + /src/main/java/com/sast/astbenchmark/model/custom/R.java + AffectedNodeName: run + 14: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/R.java AffectedNodeName: Runtime.getRuntime().exec 16: SINK: Runtime.getRuntime().exec(this.cmd); @@ -2501,6 +2471,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_007_T.java AffectedNodeName: timer 27: ARG PASS: timer.schedule(tt, 2000); + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_007_T.java + AffectedNodeName: run + 27: CALL: timer.schedule(tt, 2000); + /src/main/java/com/sast/astbenchmark/model/custom/TT.java + AffectedNodeName: run + 16: ARG PASS: public void run() { /src/main/java/com/sast/astbenchmark/model/custom/TT.java AffectedNodeName: Runtime.getRuntime().exec 18: SINK: Runtime.getRuntime().exec(this.cmd); @@ -2520,6 +2496,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_009_T.java AffectedNodeName: obj.a 32: Var Pass: obj.a = cmd; + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_009_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.multi_thread.Async_Multithreading_009_T.testcase. + 36: CALL: Thread thread2 = new Thread(() -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_009_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.multi_thread.Async_Multithreading_009_T.testcase. + 36: ARG PASS: Thread thread2 = new Thread(() -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/multi_thread/Async_Multithreading_009_T.java AffectedNodeName: Runtime.getRuntime().exec 39: SINK: Runtime.getRuntime().exec(obj.a); @@ -2581,6 +2563,12 @@ Trace: 42: CALL RETURN: // 处理结果 43: CALL RETURN: return result.get(); 44: CALL RETURN: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: CALL: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: ARG PASS: }).thenAccept(notCleanedResult -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java AffectedNodeName: Runtime.getRuntime().exec 47: SINK: Runtime.getRuntime().exec(notCleanedResult); @@ -2623,6 +2611,12 @@ Trace: 42: CALL RETURN: // 处理结果 43: CALL RETURN: return result.get(); 44: CALL RETURN: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: CALL: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: ARG PASS: }).thenAccept(notCleanedResult -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java AffectedNodeName: Runtime.getRuntime() 47: Var Pass: Runtime.getRuntime().exec(notCleanedResult); @@ -2668,6 +2662,12 @@ Trace: 42: CALL RETURN: // 处理结果 43: CALL RETURN: return result.get(); 44: CALL RETURN: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: CALL: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: ARG PASS: }).thenAccept(notCleanedResult -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java AffectedNodeName: Runtime.getRuntime() 47: Var Pass: Runtime.getRuntime().exec(notCleanedResult); @@ -2757,6 +2757,12 @@ Trace: 42: CALL RETURN: // 处理结果 43: CALL RETURN: return result.get(); 44: CALL RETURN: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: CALL: }).thenAccept(notCleanedResult -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.completeness.single_app_tracing.asynchronous_tracing.promise_callback_await.CompletableFuture_003_T.testcase. + 44: ARG PASS: }).thenAccept(notCleanedResult -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/CompletableFuture_003_T.java AffectedNodeName: Runtime.getRuntime() 47: Var Pass: Runtime.getRuntime().exec(notCleanedResult); @@ -3741,12 +3747,6 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/override/Expression_Override_001_T.java AffectedNodeName: ps 26: Var Pass: PS ps = new PS(cmd, "~"); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/override/Expression_Override_001_T.java - AffectedNodeName: getCmd - 27: CALL: Runtime.getRuntime().exec(ps.getCmd()); - /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/override/Expression_Override_001_T.java - AffectedNodeName: ps - 27: ARG PASS: Runtime.getRuntime().exec(ps.getCmd()); /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/override/Expression_Override_001_T.java AffectedNodeName: getCmd 27: CALL RETURN: Runtime.getRuntime().exec(ps.getCmd()); @@ -3800,6 +3800,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/static_method/static_field_001_T.java AffectedNodeName: MyClass.data 24: Var Pass: MyClass.data = __taint_src; + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/static_method/static_field_001_T.java + AffectedNodeName: process + 25: CALL: process(); + /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/static_method/static_field_001_T.java + AffectedNodeName: process + 28: ARG PASS: private void process() { /src/main/java/com/sast/astbenchmark/case_language_maturity/completeness/single_app_tracing/function_call/static_method/static_field_001_T.java AffectedNodeName: Runtime.getRuntime().exec 30: SINK: Runtime.getRuntime().exec(MyClass.data); @@ -4002,25 +4008,11 @@ Trace: AffectedNodeName: add 30: CALL: queue.add(cmd); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: CALL: queue.stream().forEach(e -> { - 34: CALL: if (cmd.equals(e)) { - 35: CALL: try { - 36: CALL: Runtime.getRuntime().exec(e); - 37: CALL: } catch (IOException ex) { - 38: CALL: } - 39: CALL: } - 40: CALL: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: e + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: ARG PASS: queue.stream().forEach(e -> { - 34: ARG PASS: if (cmd.equals(e)) { - 35: ARG PASS: try { - 36: ARG PASS: Runtime.getRuntime().exec(e); - 37: ARG PASS: } catch (IOException ex) { - 38: ARG PASS: } - 39: ARG PASS: } - 40: ARG PASS: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java AffectedNodeName: Runtime.getRuntime().exec 36: SINK: Runtime.getRuntime().exec(e); @@ -4037,6 +4029,12 @@ Trace: /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java AffectedNodeName: cmd 26: SOURCE: public Map testcase(@RequestParam String cmd) { + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. + 33: CALL: queue.stream().forEach(e -> { + /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. + 33: ARG PASS: queue.stream().forEach(e -> { /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java AffectedNodeName: cmd 34: Var Pass: if (cmd.equals(e)) { @@ -4060,25 +4058,11 @@ Trace: AffectedNodeName: add 30: CALL: queue.add(cmd); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: CALL: queue.stream().forEach(e -> { - 34: CALL: if (cmd.equals(e)) { - 35: CALL: try { - 36: CALL: Runtime.getRuntime().exec(e); - 37: CALL: } catch (IOException ex) { - 38: CALL: } - 39: CALL: } - 40: CALL: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: e + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: ARG PASS: queue.stream().forEach(e -> { - 34: ARG PASS: if (cmd.equals(e)) { - 35: ARG PASS: try { - 36: ARG PASS: Runtime.getRuntime().exec(e); - 37: ARG PASS: } catch (IOException ex) { - 38: ARG PASS: } - 39: ARG PASS: } - 40: ARG PASS: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java AffectedNodeName: cmd 34: Var Pass: if (cmd.equals(e)) { @@ -4102,25 +4086,11 @@ Trace: AffectedNodeName: add 30: CALL: queue.add(cmd); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: CALL: queue.stream().forEach(e -> { - 34: CALL: if (cmd.equals(e)) { - 35: CALL: try { - 36: CALL: Runtime.getRuntime().exec(e); - 37: CALL: } catch (IOException ex) { - 38: CALL: } - 39: CALL: } - 40: CALL: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java - AffectedNodeName: e + AffectedNodeName: com.sast.astbenchmark.case_language_maturity.accuracy.object_field_sensitive.field_sensitive_one_collection.numeric_index_state_no_solver.QueueWithLambda_001_T.testcase. 33: ARG PASS: queue.stream().forEach(e -> { - 34: ARG PASS: if (cmd.equals(e)) { - 35: ARG PASS: try { - 36: ARG PASS: Runtime.getRuntime().exec(e); - 37: ARG PASS: } catch (IOException ex) { - 38: ARG PASS: } - 39: ARG PASS: } - 40: ARG PASS: }); /src/main/java/com/sast/astbenchmark/case_language_maturity/accuracy/object_field_sensitive/field_sensitive_one_collection/numeric_index_state_no_solver/QueueWithLambda_001_T.java AffectedNodeName: cmd 34: Var Pass: if (cmd.equals(e)) { diff --git a/test/java/test-java-benchmark.ts b/test/java/test-java-benchmark.ts index ccba8f5b..9e99b923 100644 --- a/test/java/test-java-benchmark.ts +++ b/test/java/test-java-benchmark.ts @@ -1,5 +1,7 @@ import * as path from 'path' import { describe, it, before } from 'mocha' +// @ts-ignore +import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' const { execute } = require('../../src/interface/starter') const { ErrorCode } = require('../../src/util/error-code') const { recordFindingStr, readExpectRes, resolveFindingResult } = require('../test-utils') @@ -13,7 +15,7 @@ function runJavaBenchmark(dir: string): void { const ruleConfigFile = path.join(path.resolve(dir), '../../rule_config_xast_java.json') const repoName = path.basename(dir) const expectPath = path.join(dir, '..', '..', 'expect', `${repoName}-expect.result`) - + // 先同步读取期望结果，用于注册测试用例 let expectedResForRegistration: any = null let expectedResMapForRegistration: Map = new Map() @@ -21,7 +23,7 @@ function runJavaBenchmark(dir: string): void { expectedResForRegistration = readExpectRes(expectPath) expectedResMapForRegistration = resolveFindingResult(expectedResForRegistration) } - + describe(description, function () { this.timeout(0) let result: any @@ -29,14 +31,16 @@ function runJavaBenchmark(dir: string): void { let actualRes: any let expectedResMap: Map let actualResMap: Map + let accuracyStats: AccuracyStats | null = null let benchmarkReady = false - + before(async function () { result = await getRunJavaBenchmarkResult(dir) expectedRes = result.expectedRes actualRes = result.actualRes expectedResMap = result.expectedResMap actualResMap = result.actualResMap + accuracyStats = result.accuracyStats benchmarkReady = true }) @@ -48,7 +52,7 @@ function runJavaBenchmark(dir: string): void { logger.info(actualRes) assert.strictEqual(actualRes, expectedRes, '当前靶场扫描结果与历史预期不一致,请逐个核对链路') }) - + // 使用预先读取的期望结果注册测试用例 let i = 1 expectedResMapForRegistration.forEach((value, key) => { @@ -83,6 +87,20 @@ function runJavaBenchmark(dir: string): void { assert.fail(`new chain:${addChains.length}`) } }) + + it(`trace accuracy`, function () { + if (!benchmarkReady || !accuracyStats) { + this.skip() + return + } + const pct = + accuracyStats.evaluableHops > 0 + ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) + : 'N/A' + logger.info( + `=== Trace Accuracy [Java Benchmark]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` + ) + }) }) } @@ -91,9 +109,11 @@ async function getRunJavaBenchmarkResult(dir: string): Promise<{ actualRes: any expectedResMap: Map actualResMap: Map + accuracyStats: AccuracyStats | null }> { const ruleConfigFile = path.join(path.resolve(dir), '../../rule_config_xast_java.json') const repoName = path.basename(dir) + const reportDir = path.join(__dirname, 'report') const expectPath = path.join(dir, '..', '..', 'expect', `${repoName}-expect.result`) let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map @@ -108,6 +128,8 @@ async function getRunJavaBenchmarkResult(dir: string): Promise<{ 'SpringAnalyzer', '--checkerPackIds', 'taint-flow-java-inner', + '--report', + reportDir, ] await (async () => { try { @@ -128,11 +150,20 @@ async function getRunJavaBenchmarkResult(dir: string): Promise<{ expectedResMap = resolveFindingResult(expectedRes) actualResMap = resolveFindingResult(actualRes) + // 计算 trace 准确率 + let accuracyStats: AccuracyStats | null = null + const sarifPath = path.join(reportDir, 'report.sarif') + if (fs.existsSync(sarifPath)) { + const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) + accuracyStats = computeAccuracyFromSarif(sarifData) + } + return { expectedRes, actualRes, expectedResMap, actualResMap, + accuracyStats, } } diff --git a/test/java/test-java-real-project.ts b/test/java/test-java-real-project.ts index 868b289d..42c853c0 100644 --- a/test/java/test-java-real-project.ts +++ b/test/java/test-java-real-project.ts @@ -2,6 +2,8 @@ import path from 'path' import fs from 'fs' import { before, describe, it } from 'mocha' import assert from 'assert' +// @ts-ignore +import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' const { execute } = require('../../src/interface/starter') const { handleException } = require('../../src/engine/analyzer/common/exception-handler') const { ErrorCode } = require('../../src/util/error-code') @@ -26,6 +28,7 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin let actualRes: any let expectedResMap: Map let actualResMap: Map + let accuracyStats: AccuracyStats | null = null let benchmarkReady = false before(async function () { @@ -34,6 +37,7 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin actualRes = result.actualRes expectedResMap = result.expectedResMap actualResMap = result.actualResMap + accuracyStats = result.accuracyStats benchmarkReady = true }) @@ -80,6 +84,20 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin assert.fail(`new chain:${addChains.length}`) } }) + + it(`trace accuracy`, function () { + if (!benchmarkReady || !accuracyStats) { + this.skip() + return + } + const pct = + accuracyStats.evaluableHops > 0 + ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) + : 'N/A' + logger.info( + `=== Trace Accuracy [${repoName}]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` + ) + }) }) } @@ -103,8 +121,10 @@ async function getRunJavaBenchmarkResult( actualRes: any expectedResMap: Map actualResMap: Map + accuracyStats: AccuracyStats | null }> { const repoName = path.basename(dir) + const reportDir = path.join(__dirname, 'report', repoName) let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map let recorder = recordFindingStr() @@ -120,6 +140,8 @@ async function getRunJavaBenchmarkResult( 'taint-flow-java-inner', '--entrypointMode', 'ONLY_CUSTOM', + '--report', + reportDir, ] await (async () => { try { @@ -140,11 +162,20 @@ async function getRunJavaBenchmarkResult( expectedResMap = resolveFindingResult(expectedRes) actualResMap = resolveFindingResult(actualRes) + // 计算 trace 准确率 + let accuracyStats: AccuracyStats | null = null + const sarifPath = path.join(reportDir, 'report.sarif') + if (fs.existsSync(sarifPath)) { + const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) + accuracyStats = computeAccuracyFromSarif(sarifData) + } + return { expectedRes, actualRes, expectedResMap, actualResMap, + accuracyStats, } } @@ -181,8 +212,8 @@ async function updateExpect(dir: string, ruleConfigFile: string, expectPath: str }) } -// const dir = '' -// runMultiProject(dir) +const dir = '/Users/jiufo/yasaaaaa/Code-Regression-Real/Normal' +runMultiProject(dir) // const dir = '' // runSingleProject(dir, dir + '.json', dir + '.result') diff --git a/test/javascript/expect/chairbenchmark-expect.result b/test/javascript/expect/chairbenchmark-expect.result new file mode 100644 index 00000000..a183510f --- /dev/null +++ b/test/javascript/expect/chairbenchmark-expect.result @@ -0,0 +1,1119 @@ +======================== Findings ======================== + +------------- 1: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrf_app_rpcAndGet_ts.ts +Line 6: this.ctx.curl(aa) +SINK RULE:this.ctx.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrf_app_rpcAndGet_ts.ts","functionName":"testSsrf","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrf_app_rpcAndGet_ts.ts + AffectedNodeName: aa + 5: SOURCE: async testSsrf(aa) { + /app/controller/ssrf_app_rpcAndGet_ts.ts + AffectedNodeName: this.ctx.curl + 6: SINK: const result = await this.ctx.curl(aa); + +------------- 2: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/level_test_2.ts +Line [22, 25]: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({with(genBaseParams(ctx)), with(params)}) +SINK RULE:ctx.oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"count_day","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: params + 19: SOURCE: params: any, + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay + 22: SINK: const res = await oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({ + 23: SINK: ...genBaseParams(ctx), + 24: SINK: ...params, + 25: SINK: }); + +------------- 3: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/level_test_2.ts +Line [22, 25]: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({with(genBaseParams(ctx)), with(params)}) +SINK RULE:ctx.oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"count_day","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: user.userId + 8: SOURCE: operatorId: user?.userId || '', + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: + 23: CALL RETURN: ...genBaseParams(ctx), + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay + 22: SINK: const res = await oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({ + 23: SINK: ...genBaseParams(ctx), + 24: SINK: ...params, + 25: SINK: }); + +------------- 4: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/LevelParamSelf2.js +Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) +SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/LevelParamSelf2.js","functionName":"paramself","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: instId + 4: SOURCE: async paramself(advisorId,instId) { + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: req + 5: Var Pass: const req = { + 6: Var Pass: instId, + 7: Var Pass: advisorId, + 8: Var Pass: }; + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList + 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); + +------------- 5: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/LevelParamSelf2.js +Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) +SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/LevelParamSelf2.js","functionName":"paramself","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: advisorId + 4: SOURCE: async paramself(advisorId,instId) { + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: req + 5: Var Pass: const req = { + 6: Var Pass: instId, + 7: Var Pass: advisorId, + 8: Var Pass: }; + /app/controller/Level_test/LevelParamSelf2.js + AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList + 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); + +------------- 6: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/LevelParamSelf3.js +Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) +SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/LevelParamSelf3.js","functionName":"paramself3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: instId + 4: SOURCE: async paramself3(advisorId: any,instId: any) { + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: req + 5: Var Pass: const req = { + 6: Var Pass: instId, + 7: Var Pass: advisorId, + 8: Var Pass: }; + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList + 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); + +------------- 7: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/LevelParamSelf3.js +Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) +SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/LevelParamSelf3.js","functionName":"paramself3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: advisorId + 4: SOURCE: async paramself3(advisorId: any,instId: any) { + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: req + 5: Var Pass: const req = { + 6: Var Pass: instId, + 7: Var Pass: advisorId, + 8: Var Pass: }; + /app/controller/Level_test/LevelParamSelf3.js + AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList + 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); + +------------- 8: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/level_test_2.ts +Line 37: this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo(req) +SINK RULE:this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"getAdvisorReservoirManagementInfo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: this.ctx.request + 35: SOURCE: ...this.ctx.request.query + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: req + 34: Var Pass: const req = { + 35: Var Pass: ...this.ctx.request.query + 36: Var Pass: }; + /app/controller/Level_test/level_test_2.ts + AffectedNodeName: this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo + 37: SINK: const res = await this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo(req); + +------------- 9: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/level_test_3.ts +Line 11: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) +SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/level_test_3.ts","functionName":"queryAdvisorRankListFacade","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/level_test_3.ts + AffectedNodeName: this.ctx.request + 7: SOURCE: ...this.ctx.request.body, + /app/controller/Level_test/level_test_3.ts + AffectedNodeName: req + 6: Var Pass: const req = { + 7: Var Pass: ...this.ctx.request.body, + 8: Var Pass: instId, + 9: Var Pass: advisorId, + 10: Var Pass: }; + /app/controller/Level_test/level_test_3.ts + AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList + 11: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); + +------------- 10: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrfHttp.ts +Line 17: this.ctx.curl(__ttt__) +SINK RULE:this.ctx.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrfHttp.ts","functionName":"testhttp","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrfHttp.ts + AffectedNodeName: this.ctx.request + 15: SOURCE: const { abc } = this.ctx.request; + /app/controller/ssrfHttp.ts + AffectedNodeName: abc + 15: Var Pass: const { abc } = this.ctx.request; + /app/controller/ssrfHttp.ts + AffectedNodeName: __ttt__ + 16: Var Pass: const { __ttt__ } = abc; + /app/controller/ssrfHttp.ts + AffectedNodeName: this.ctx.curl + 17: SINK: const a = await this.ctx.curl(__ttt__); + +------------- 11: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrfHttp.ts +Line 22: this.app.curl(this.ctx.params) +SINK RULE:this.app.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrfHttp.ts","functionName":"testhttp3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrfHttp.ts + AffectedNodeName: this.ctx.params + 22: SOURCE: const appCurl = await this.app.curl(this.ctx.params); + /app/controller/ssrfHttp.ts + AffectedNodeName: this.app.curl + 22: SINK: const appCurl = await this.app.curl(this.ctx.params); + +------------- 12: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/vm2Test.js +Line 7: new VM().run(a) +SINK RULE:vm2.VM.run +SINK Attribute:NodejsVm2Run +entrypoint: +{"filePath":"/app/controller/vm2Test.js","functionName":"testVm2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/vm2Test.js + AffectedNodeName: this.ctx.query + 6: SOURCE: const a= this.ctx.query.a; + /app/controller/vm2Test.js + AffectedNodeName: a + 6: Var Pass: const a= this.ctx.query.a; + /app/controller/vm2Test.js + AffectedNodeName: new VM().run + 7: SINK: new VM().run(a) + +------------- 13: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/iteratorNextTest.js +Line 11: it.next(this.ctx.query.a) +SINK RULE:dom-iterator.next +entrypoint: +{"filePath":"/app/controller/iteratorNextTest.js","functionName":"testNext","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/iteratorNextTest.js + AffectedNodeName: this.ctx.query + 11: SOURCE: while (next = it.next(this.ctx.query.a)) { } + /app/controller/iteratorNextTest.js + AffectedNodeName: it.next + 11: SINK: while (next = it.next(this.ctx.query.a)) { } + +------------- 14: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/vm2Test.js +Line 13: VMInstance.run(a) +SINK RULE:vm2.VM.run +SINK Attribute:NodejsVm2Run +entrypoint: +{"filePath":"/app/controller/vm2Test.js","functionName":"testVm21","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/vm2Test.js + AffectedNodeName: this.ctx.query + 11: SOURCE: const a = this.ctx.query.a; + /app/controller/vm2Test.js + AffectedNodeName: a + 11: Var Pass: const a = this.ctx.query.a; + /app/controller/vm2Test.js + AffectedNodeName: VMInstance.run + 13: SINK: VMInstance.run(a) + +------------- 15: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/mysql2Test.js +Line [20, 28]: conn.query(sql, function (var err:any, var result:any){{{conn.end(), if(err){{reject(err)}}, resolve(result)}}}) +SINK RULE:conn.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/mysql2Test.js","functionName":"test1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/mysql2Test.js + AffectedNodeName: sql + 16: SOURCE: async test1(sql) { + /app/controller/mysql2Test.js + AffectedNodeName: /app/controller/mysql2Test.mysql2Test.test1. + 19: CALL: return new Promise(function (resolve, reject) { + /app/controller/mysql2Test.js + AffectedNodeName: /app/controller/mysql2Test.mysql2Test.test1. + 19: ARG PASS: return new Promise(function (resolve, reject) { + /app/controller/mysql2Test.js + AffectedNodeName: conn.query + 20: SINK: conn.query(sql, function (err, result) { + 21: SINK: conn.end() + 22: SINK: + 23: SINK: if (err) { + 24: SINK: reject(err) + 25: SINK: } + 26: SINK: + 27: SINK: resolve(result) + 28: SINK: }) + +------------- 16: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/mysql2Test.js +Line [33, 39]: createConnection({user:config.user, password:config.password, host:config.host, port:config.port, database:config.database}).query(sql) +SINK RULE:mysql2.createConnection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/mysql2Test.js","functionName":"test2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/mysql2Test.js + AffectedNodeName: sql + 32: SOURCE: async test2(sql) { + /app/controller/mysql2Test.js + AffectedNodeName: createConnection({user:config.user, password:config.password, host:config.host, port:config.port, database:config.database}).query + 33: SINK: return createConnection({ + 34: SINK: user: config.user, + 35: SINK: password: config.password, + 36: SINK: host: config.host, + 37: SINK: port: config.port, + 38: SINK: database: config.database + 39: SINK: }).query(sql) + +------------- 17: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/File.js +Line 51: require(ssh2-sftp-client).get(Path) +SINK RULE:ssh2-sftp-client.get +SINK Attribute:NodejsFileOperator +entrypoint: +{"filePath":"/app/controller/File.js","functionName":"upload2SftpWhite2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/File.js + AffectedNodeName: this.ctx.request + 32: SOURCE: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: path + 32: Var Pass: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: fileName + 36: Var Pass: const fileName = path; + /app/controller/File.js + AffectedNodeName: Path + 40: Var Pass: const Path = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; + /app/controller/File.js + AffectedNodeName: require(ssh2-sftp-client).get + 51: SINK: await require('ssh2-sftp-client').get(Path); + +------------- 18: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/File.js +Line 74: sftp.put(stream, ossPath) +SINK RULE:ssh2-sftp-client.put +SINK Attribute:NodejsFileOperator +entrypoint: +{"filePath":"/app/controller/File.js","functionName":"upload2SftpBlack","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/File.js + AffectedNodeName: this.ctx.request + 61: SOURCE: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: path + 61: Var Pass: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: fileName + 66: Var Pass: const fileName = path; + /app/controller/File.js + AffectedNodeName: ossPath + 70: Var Pass: const ossPath = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; + /app/controller/File.js + AffectedNodeName: sftp.put + 74: SINK: await sftp.put(stream, ossPath); + +------------- 19: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/File.js +Line 97: require(ssh2-sftp-client).get(ossPath) +SINK RULE:ssh2-sftp-client.get +SINK Attribute:NodejsFileOperator +entrypoint: +{"filePath":"/app/controller/File.js","functionName":"upload2SftpBlack2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/File.js + AffectedNodeName: this.ctx.request + 86: SOURCE: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: path + 86: Var Pass: const { path } = this.ctx.request; + /app/controller/File.js + AffectedNodeName: fileName + 89: Var Pass: const fileName = path; + /app/controller/File.js + AffectedNodeName: ossPath + 93: Var Pass: const ossPath = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; + /app/controller/File.js + AffectedNodeName: require(ssh2-sftp-client).get + 97: SINK: await require('ssh2-sftp-client').get(ossPath); + +------------- 20: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 8: this.ctx.app.mysql.query(queryStr) +SINK RULE:this.ctx.app.mysql.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggMysqlBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 5: SOURCE: async eggMysqlBlack1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 6: Var Pass: let sqlString = ` + 7: Var Pass: SELECT uk_cluster_name,cluster_type + 8: Var Pass: FROM cluster + 9: Var Pass: WHERE uk_cluster_name LIKE '%${fuzzyStr}%' + 10: Var Pass: ` + /app/controller/sqlEggMysql.js + AffectedNodeName: query + 11: CALL: let result = await ctx.service.sql.query(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 6: ARG PASS: async query(queryStr) { + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.query. + 8: CALL: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.query. + 8: ARG PASS: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: this.ctx.app.mysql.query + 8: SINK: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + +------------- 21: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 13: connection.query(queryStr) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 23: SOURCE: async eggConnBlack1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 24: Var Pass: let sqlString = "UPDATE posts SET title = "+ fuzzyStr + /app/controller/sqlEggMysql.js + AffectedNodeName: connQuery + 25: CALL: let result = await this.ctx.service.sql.connQuery(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 11: ARG PASS: async connQuery(queryStr){ + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.connQuery. + 13: CALL: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.connQuery. + 13: ARG PASS: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: connection.query + 13: SINK: const record = await co(function * () { return yield connection.query(queryStr) }) + +------------- 22: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 14: connection.query(queryStr) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 23: SOURCE: async eggConnBlack1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 24: Var Pass: let sqlString = "UPDATE posts SET title = "+ fuzzyStr + /app/controller/sqlEggMysql.js + AffectedNodeName: connQuery + 25: CALL: let result = await this.ctx.service.sql.connQuery(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 11: ARG PASS: async connQuery(queryStr){ + /app/service/sql.js + AffectedNodeName: [return value] + 13: Return Value: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: + 13: CALL RETURN: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: record + 13: Var Pass: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: connection.query + 14: SINK: const res = connection.query(queryStr); + +------------- 23: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 8: this.ctx.app.mysql.query(queryStr) +SINK RULE:this.ctx.app.mysql.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggMysqlWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 14: SOURCE: async eggMysqlWhite1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 15: Var Pass: let sqlString = ` + 16: Var Pass: SELECT uk_cluster_name,cluster_type + 17: Var Pass: FROM cluster + 18: Var Pass: WHERE uk_cluster_name LIKE '%${mysql.escape(fuzzyStr)}%' + 19: Var Pass: ` + /app/controller/sqlEggMysql.js + AffectedNodeName: query + 20: CALL: let result = await ctx.service.sql.query(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 6: ARG PASS: async query(queryStr) { + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.query. + 8: CALL: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.query. + 8: ARG PASS: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: this.ctx.app.mysql.query + 8: SINK: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) + +------------- 24: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 13: connection.query(queryStr) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 27: SOURCE: async eggConnWhite1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 28: Var Pass: let sqlString = "UPDATE posts SET title = "+ mysql.escape(fuzzyStr) + /app/controller/sqlEggMysql.js + AffectedNodeName: connQuery + 29: CALL: let result = await ctx.service.sql.connQuery(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 11: ARG PASS: async connQuery(queryStr){ + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.connQuery. + 13: CALL: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: /app/service/sql.Sql.connQuery. + 13: ARG PASS: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: connection.query + 13: SINK: const record = await co(function * () { return yield connection.query(queryStr) }) + +------------- 25: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/service/sql.js +Line 14: connection.query(queryStr) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 27: SOURCE: async eggConnWhite1(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: sqlString + 28: Var Pass: let sqlString = "UPDATE posts SET title = "+ mysql.escape(fuzzyStr) + /app/controller/sqlEggMysql.js + AffectedNodeName: connQuery + 29: CALL: let result = await ctx.service.sql.connQuery(sqlString) + /app/service/sql.js + AffectedNodeName: queryStr + 11: ARG PASS: async connQuery(queryStr){ + /app/service/sql.js + AffectedNodeName: [return value] + 13: Return Value: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: + 13: CALL RETURN: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: record + 13: Var Pass: const record = await co(function * () { return yield connection.query(queryStr) }) + /app/service/sql.js + AffectedNodeName: connection.query + 14: SINK: const res = connection.query(queryStr); + +------------- 26: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/sqlEggMysql.js +Line 33: connection.query(mysql.escape(fuzzyStr)) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqlEggMysql.js + AffectedNodeName: fuzzyStr + 31: SOURCE: async eggConnWhite2(fuzzyStr) { + /app/controller/sqlEggMysql.js + AffectedNodeName: /app/controller/sqlEggMysql.SqlEggMysql.eggConnWhite2. + 33: CALL: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) + /app/controller/sqlEggMysql.js + AffectedNodeName: /app/controller/sqlEggMysql.SqlEggMysql.eggConnWhite2. + 33: ARG PASS: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) + /app/controller/sqlEggMysql.js + AffectedNodeName: connection.query + 33: SINK: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) + +------------- 27: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/VariableCover/variable_cover_3.js +Line 23: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/VariableCover/variable_cover_3.js","functionName":"echo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: ctx.userId + 17: SOURCE: const { uid } = ctx.userId; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: uid + 17: Var Pass: const { uid } = ctx.userId; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: newParmas + 19: Var Pass: const newParmas = { + 20: Var Pass: uid, + 21: Var Pass: ...params, + 22: Var Pass: }; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 23: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas); + +------------- 28: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/VariableCover/variable_cover_3.js +Line 23: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/VariableCover/variable_cover_3.js","functionName":"echo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: ctx.request + 18: SOURCE: const params = ctx.request.body; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: params + 18: Var Pass: const params = ctx.request.body; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: newParmas + 19: Var Pass: const newParmas = { + 20: Var Pass: uid, + 21: Var Pass: ...params, + 22: Var Pass: }; + /app/controller/VariableCover/variable_cover_3.js + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 23: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas); + +------------- 29: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrfHttpTwo.js +Line 13: this.app.curl(this.ctx.params) +SINK RULE:this.app.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrfHttpTwo.js","functionName":"testAppSsrf2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrfHttpTwo.js + AffectedNodeName: this.ctx.params + 13: SOURCE: const appCurl = await this.app.curl(this.ctx.params); + /app/controller/ssrfHttpTwo.js + AffectedNodeName: this.app.curl + 13: SINK: const appCurl = await this.app.curl(this.ctx.params); + +------------- 30: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrfHttpTwo.js +Line 7: bb.curl(this.ctx.request) +SINK RULE:this.ctx.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrfHttpTwo.js","functionName":"testSsrf2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrfHttpTwo.js + AffectedNodeName: this.ctx.request + 7: SOURCE: const a = await bb.curl(this.ctx.request); + /app/controller/ssrfHttpTwo.js + AffectedNodeName: bb.curl + 7: SINK: const a = await bb.curl(this.ctx.request); + +------------- 31: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/module_deserialize_directly_call.js +Line 14: require(node-serialize).unserialize(str) +SINK RULE:node-serialize.unserialize +SINK Attribute:NodejsModuleDeserialize +entrypoint: +{"filePath":"/app/controller/module_deserialize_directly_call.js","functionName":"moduleDeserializeTest","attribute":"HTTP","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/module_deserialize_directly_call.js + AffectedNodeName: ctx.request + 13: SOURCE: const str = ctx.request.cookies.profile; + /app/controller/module_deserialize_directly_call.js + AffectedNodeName: str + 13: Var Pass: const str = ctx.request.cookies.profile; + /app/controller/module_deserialize_directly_call.js + AffectedNodeName: require(node-serialize).unserialize + 14: SINK: const obj = require('node-serialize').unserialize(str); + +------------- 32: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/cmd_mgw_ts.ts +Line 14: eval(ctx.request.a) +SINK RULE:eval +SINK Attribute:NodejsExec +entrypoint: +{"filePath":"/app/controller/cmd_mgw_ts.ts","functionName":"eval_mgw","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/cmd_mgw_ts.ts + AffectedNodeName: ctx.request + 14: SOURCE: const res = eval(ctx.request.a); + /app/controller/cmd_mgw_ts.ts + AffectedNodeName: eval + 14: SINK: const res = eval(ctx.request.a); + +------------- 33: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/LevelParamSelf4.js +Line 12: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/LevelParamSelf4.js","functionName":"lps4","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/LevelParamSelf4.js + AffectedNodeName: params + 10: SOURCE: params: { cardNo: string }, + /app/controller/Level_test/LevelParamSelf4.js + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 12: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo); + +------------- 34: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/Level_test.ts +Line 12: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/Level_test.ts","functionName":"hasHistRepayRecord","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/Level_test.ts + AffectedNodeName: params + 10: SOURCE: params: { cardNo: string }, + /app/controller/Level_test/Level_test.ts + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 12: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo); + +------------- 35: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/Level_test/level_test_4.ts +Line 9: this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum(trParams) +SINK RULE:this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/Level_test/level_test_4.ts","functionName":"rpc_level_test_4","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/Level_test/level_test_4.ts + AffectedNodeName: params + 5: SOURCE: async rpc_level_test_4(params: any) { // 224621 + /app/controller/Level_test/level_test_4.ts + AffectedNodeName: trParams + 6: Var Pass: const trParams = { + 7: Var Pass: ...params, + 8: Var Pass: }; + /app/controller/Level_test/level_test_4.ts + AffectedNodeName: this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum + 9: SINK: const result = await this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum(trParams); + +------------- 36: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/mgw.ts +Line 27: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/mgw.ts","functionName":"hello","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/mgw.ts + AffectedNodeName: ctx.userId + 23: SOURCE: siteUserId: ctx.userId,//mmm + /app/controller/mgw.ts + AffectedNodeName: queryParams + 22: Var Pass: const queryParams = { + 23: Var Pass: siteUserId: ctx.userId,//mmm + 24: Var Pass: ...params, + 25: Var Pass: + 26: Var Pass: }; + /app/controller/mgw.ts + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 27: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); + +------------- 37: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/mgw.ts +Line 27: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/mgw.ts","functionName":"hello","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/mgw.ts + AffectedNodeName: params + 20: SOURCE: params: { cardNo: string }, + /app/controller/mgw.ts + AffectedNodeName: queryParams + 22: Var Pass: const queryParams = { + 23: Var Pass: siteUserId: ctx.userId,//mmm + 24: Var Pass: ...params, + 25: Var Pass: + 26: Var Pass: }; + /app/controller/mgw.ts + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 27: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); + +------------- 38: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/module_deserialize_mrpc_directly_call.js +Line 12: require(node-serialize).unserialize(str) +SINK RULE:node-serialize.unserialize +SINK Attribute:NodejsModuleDeserialize +entrypoint: +{"filePath":"/app/controller/module_deserialize_mrpc_directly_call.js","functionName":"moduleDeserializeMrpcTest","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/module_deserialize_mrpc_directly_call.js + AffectedNodeName: ctx.request + 11: SOURCE: const str = ctx.request.cookies.profile; + /app/controller/module_deserialize_mrpc_directly_call.js + AffectedNodeName: str + 11: Var Pass: const str = ctx.request.cookies.profile; + /app/controller/module_deserialize_mrpc_directly_call.js + AffectedNodeName: require(node-serialize).unserialize + 12: SINK: const obj = require('node-serialize').unserialize(str); + +------------- 39: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/sqli_app_rpc_ts.ts +Line [10, 12]: connection.query(SELECT * FROM projects WHERE id =+this.ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sqli_app_rpc_ts.ts","functionName":"sqli_controller","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sqli_app_rpc_ts.ts + AffectedNodeName: this.ctx.request + 10: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { + /app/controller/sqli_app_rpc_ts.ts + AffectedNodeName: connection.query + 10: SINK: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { + 11: SINK: if (err) throw err; + 12: SINK: }); + +------------- 40: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/sql_mgw_ts.ts +Line [23, 25]: connection.query(SELECT * FROM projects WHERE id =+ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/controller/sql_mgw_ts.ts","functionName":"sql_mgw","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/sql_mgw_ts.ts + AffectedNodeName: ctx.request + 23: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + ctx.request.body.data, function (err) { + /app/controller/sql_mgw_ts.ts + AffectedNodeName: connection.query + 23: SINK: connection.query('SELECT * FROM projects WHERE id =' + ctx.request.body.data, function (err) { + 24: SINK: if (err) throw err; + 25: SINK: }); + +------------- 41: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/ssrf_app_rpcAndGet_ts.ts +Line 6: this.ctx.curl(aa) +SINK RULE:this.ctx.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/controller/ssrf_app_rpcAndGet_ts.ts","functionName":"testSsrf","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/ssrf_app_rpcAndGet_ts.ts + AffectedNodeName: aa + 5: SOURCE: async testSsrf(aa) { + /app/controller/ssrf_app_rpcAndGet_ts.ts + AffectedNodeName: this.ctx.curl + 6: SINK: const result = await this.ctx.curl(aa); + +------------- 42: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/VariableCover/variable_cover_2.js +Line 17: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/VariableCover/variable_cover_2.js","functionName":"hhhh","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: ctx.userId + 13: SOURCE: siteUserId: ctx.userId,//mmm + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: queryParams + 12: Var Pass: const queryParams = { + 13: Var Pass: siteUserId: ctx.userId,//mmm + 14: Var Pass: ...params, + 15: Var Pass: + 16: Var Pass: }; + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 17: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); + +------------- 43: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/controller/VariableCover/variable_cover_2.js +Line 17: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) +SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord +SINK Attribute:NodejsLevelAuthority +entrypoint: +{"filePath":"/app/controller/VariableCover/variable_cover_2.js","functionName":"hhhh","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: params + 10: SOURCE: params: { cardNo: string }, + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: queryParams + 12: Var Pass: const queryParams = { + 13: Var Pass: siteUserId: ctx.userId,//mmm + 14: Var Pass: ...params, + 15: Var Pass: + 16: Var Pass: }; + /app/controller/VariableCover/variable_cover_2.js + AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord + 17: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); + +------------- 44: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/cmd_twa_js.js +Line [19, 24]: childProcess.exec(this.ctx.request.body.cmd, function (var error:any, var stdout:any, var stderr:any){{{if(error){{reject(error)}}, resolve(stdout)}}}) +SINK RULE:child_process.exec +SINK Attribute:NodejsExec +entrypoint: +{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval01_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/cmd_twa_js.js + AffectedNodeName: this.ctx.request + 19: SOURCE: childProcess.exec(this.ctx.request.body.cmd, (error, stdout, stderr) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval01_twa. + 18: CALL: const body = await new Promise((resolve, reject) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval01_twa. + 18: ARG PASS: const body = await new Promise((resolve, reject) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: childProcess.exec + 19: SINK: childProcess.exec(this.ctx.request.body.cmd, (error, stdout, stderr) => { + 20: SINK: if (error) { + 21: SINK: reject(error); + 22: SINK: } + 23: SINK: resolve(stdout); + 24: SINK: }); + +------------- 45: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/cmd_twa_js.js +Line [38, 43]: require(child_process).spawn(this.ctx.request.body.cmd, function (var error:any, var stdout:any, var stderr:any){{{if(error){{reject(error)}}, resolve(stdout)}}}) +SINK RULE:child_process.spawn +SINK Attribute:NodejsExec +entrypoint: +{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval02_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/cmd_twa_js.js + AffectedNodeName: this.ctx.request + 38: SOURCE: require('child_process').spawn(this.ctx.request.body.cmd, (error, stdout, stderr) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval02_twa. + 37: CALL: const body = await new Promise((resolve, reject) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval02_twa. + 37: ARG PASS: const body = await new Promise((resolve, reject) => { + /app/rpc/cmd_twa_js.js + AffectedNodeName: require(child_process).spawn + 38: SINK: require('child_process').spawn(this.ctx.request.body.cmd, (error, stdout, stderr) => { + 39: SINK: if (error) { + 40: SINK: reject(error); + 41: SINK: } + 42: SINK: resolve(stdout); + 43: SINK: }); + +------------- 46: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/cmd_twa_js.js +Line 6: eval(this.ctx.request.body.cmd) +SINK RULE:eval +SINK Attribute:NodejsExec +entrypoint: +{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/cmd_twa_js.js + AffectedNodeName: this.ctx.request + 6: SOURCE: const body = eval(this.ctx.request.body.cmd); + /app/rpc/cmd_twa_js.js + AffectedNodeName: eval + 6: SINK: const body = eval(this.ctx.request.body.cmd); + +------------- 47: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/sql_twa_js.js +Line [15, 17]: connection.query(SELECT * FROM projects WHERE id =+this.ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) +SINK RULE:connection.query +SINK Attribute:NodejsSqlInjection +entrypoint: +{"filePath":"/app/rpc/sql_twa_js.js","functionName":"sql_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/sql_twa_js.js + AffectedNodeName: this.ctx.request + 15: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { + /app/rpc/sql_twa_js.js + AffectedNodeName: connection.query + 15: SINK: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { + 16: SINK: if (err) throw err; + 17: SINK: }); + +------------- 48: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/ssrf_twa_js.js +Line 23: this.app.curl(this.ctx.request.query.url) +SINK RULE:this.app.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"getProxy01_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/ssrf_twa_js.js + AffectedNodeName: this.ctx.request + 23: SOURCE: const result = await this.app.curl(this.ctx.request.query.url); + /app/rpc/ssrf_twa_js.js + AffectedNodeName: this.app.curl + 23: SINK: const result = await this.app.curl(this.ctx.request.query.url); + +------------- 49: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/ssrf_twa_js.js +Line 36: ctx.service.xdevapi.curl(url) +SINK RULE:this.app.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"getProxy02_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/ssrf_twa_js.js + AffectedNodeName: ctx.query + 35: SOURCE: const { url } = ctx.query; + /app/rpc/ssrf_twa_js.js + AffectedNodeName: url + 35: Var Pass: const { url } = ctx.query; + /app/rpc/ssrf_twa_js.js + AffectedNodeName: ctx.service.xdevapi.curl + 36: SINK: const result = await ctx.service.xdevapi.curl(url); + +------------- 50: taint_flow_egg_input------------- +Description:JavaScript Egg框架污点分析checker +File:/app/rpc/ssrf_twa_js.js +Line [13, 18]: this.ctx.curl(url_test, {headers:{bakery-token:this.ctx.extraConfig.BAKERY_SPM_TOKEN}, data:this.ctx.query}) +SINK RULE:this.ctx.curl +SINK Attribute:NodejsSSRF +entrypoint: +{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"ssrf_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} +Trace: + /app/rpc/ssrf_twa_js.js + AffectedNodeName: test_a + 5: SOURCE: async ssrf_twa(test_a) { + /app/rpc/ssrf_twa_js.js + AffectedNodeName: UrlReq + 6: Var Pass: const UrlReq = { + 7: Var Pass: url: test_a, + 8: Var Pass: userId: this.ctx.userId, + 9: Var Pass: }; + /app/rpc/ssrf_twa_js.js + AffectedNodeName: url_test + 12: Var Pass: const url_test = UrlReq.url; + /app/rpc/ssrf_twa_js.js + AffectedNodeName: this.ctx.curl + 13: SINK: const res = await this.ctx.curl(url_test, { + 14: SINK: headers: { + 15: SINK: 'bakery-token': this.ctx.extraConfig.BAKERY_SPM_TOKEN, + 16: SINK: }, + 17: SINK: data: this.ctx.query, + 18: SINK: }); +========================================================== + #Total-findings:50 +========================================================== \ No newline at end of file diff --git a/test/javascript/expect/jsbenchmark-expect.json b/test/javascript/expect/jsbenchmark-expect.json index 1df30acb..d38a9c26 100644 --- a/test/javascript/expect/jsbenchmark-expect.json +++ b/test/javascript/expect/jsbenchmark-expect.json @@ -1 +1 @@ -{"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\nLine 14: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\",\"functionName\":\"argument_passing_value_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function argument_passing_value_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: process\n 11: CALL: process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\nLine 15: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\",\"functionName\":\"argument_passing_value_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_value_003_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"_\");\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\nLine 12: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\",\"functionName\":\"return_value_passing_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function return_value_passing_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: process\n 11: CALL RETURN: let data = process();\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: data\n 11: Var Pass: let data = process();\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\nLine 13: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\",\"functionName\":\"multi_invoke_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function multi_invoke_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: process\n 11: CALL: let a = process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: arg\n 15: ARG PASS: function process(arg) {\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: [return value]\n 16: Return Value: return arg;\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: process\n 11: CALL RETURN: let a = process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: a\n 11: Var Pass: let a = process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(a);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\nLine 26: __taint_sink(sub.call())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\",\"functionName\":\"polymorphism_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function polymorphism_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: call\n 26: CALL RETURN: __taint_sink(sub.call());\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(sub.call());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/solver/polymorphism_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/solver/polymorphism_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\nLine 20: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\",\"functionName\":\"constructor_field_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_field_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: obj\n 19: Var Pass: let obj = new A();\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\nLine 20: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\",\"functionName\":\"constructor_field_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_field_004_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: constructor\n 19: CALL: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: param\n 13: ARG PASS: constructor(param) {\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = param;\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: obj\n 19: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\nLine 32: __taint_sink(a.b.c.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\",\"functionName\":\"field_len_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.data\n 26: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: a\n 31: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: __taint_sink\n 32: SINK: __taint_sink(a.b.c.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\nLine 52: __taint_sink(s1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\",\"functionName\":\"field_len_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.data\n 44: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.f\n 38: Var Pass: this.f = new F();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.e\n 32: Var Pass: this.e = new E();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.d\n 26: Var Pass: this.d = new D();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: a\n 49: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: s\n 50: Var Pass: const s = a.b.c;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: s1\n 51: Var Pass: const s1 = s.d.e.f.data;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: __taint_sink\n 52: SINK: __taint_sink(s1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\nLine 86: __taint_sink(a.b.c.d.e.f.g.h.i.j.k.l.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\",\"functionName\":\"field_len_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_005_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.data\n 80: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.l\n 74: Var Pass: this.l = new L();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.k\n 68: Var Pass: this.k = new K();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.j\n 62: Var Pass: this.j = new J();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.i\n 56: Var Pass: this.i = new I();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.h\n 50: Var Pass: this.h = new H();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.g\n 44: Var Pass: this.g = new G();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.f\n 38: Var Pass: this.f = new F();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.e\n 32: Var Pass: this.e = new E();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.d\n 26: Var Pass: this.d = new D();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: a\n 85: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: __taint_sink\n 86: SINK: __taint_sink(a.b.c.d.e.f.g.h.i.j.k.l.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\nLine 13: __taint_sink(s.0.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\",\"functionName\":\"array_multidimensional_collection_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_multidimensional_collection_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[0][0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\nLine 13: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\",\"functionName\":\"array_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\",\"functionName\":\"array_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\nLine 15: __taint_sink(map.get(key1))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\",\"functionName\":\"map_field_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.get(\"key1\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\nLine 17: __taint_sink(map.get(key2))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\",\"functionName\":\"map_field_sensitive_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_004_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: set\n 15: CALL: map.set(\"key2\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(map.get(\"key2\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\nLine 15: __taint_sink(map.values())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\",\"functionName\":\"map_field_sensitive_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_006_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.values());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\nLine 15: __taint_sink(map.keys())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\",\"functionName\":\"map_field_sensitive_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_008_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: set\n 13: CALL: map.set(__taint_src, \"value1\");\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.keys());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\nLine 16: __taint_sink(args.1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\",\"functionName\":\"rest_parameter_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs(\"prefix\", __taint_src, \"suffix\");\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args[1]);\n 17: Var Pass: }\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args[1]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\nLine 15: __taint_sink(rest.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\",\"functionName\":\"spread_operator_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: foo\n 12: Var Pass: const foo = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __tmp2__\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: rest\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(rest[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\nLine 14: __taint_sink(array.3)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\",\"functionName\":\"spread_operator_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: array1\n 12: Var Pass: let array1 = [\"a\", \"b\", __taint_src];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: array\n 13: Var Pass: let array = [\"c\", ...array1];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(array[3]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\nLine 13: __taint_sink(s.1+1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\",\"functionName\":\"array_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [\"a\", \"b\", __taint_src, \"c\", \"d\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[1 + 1]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\nLine 13: __taint_sink(s.1+2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\",\"functionName\":\"array_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: s\n 12: Var Pass: let s = [\"a\", \"b\", __taint_src, \"c\", \"d\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[1 + 2]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\nLine 14: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\",\"functionName\":\"asynchronous_await_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: async function asynchronous_await_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: resolve\n 19: CALL: resolve(__taint_src);\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\",\"functionName\":\"dowhile_body_loop_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_loop_stmt_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\nLine 14: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\",\"functionName\":\"dowhile_body_loop_stmt_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_loop_stmt_002_F(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\",\"functionName\":\"for_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\",\"functionName\":\"for_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_002_F(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\",\"functionName\":\"for_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_003_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: res\n 14: Var Pass: for (res = __taint_src; i < 1; i++) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\",\"functionName\":\"assign_expression_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function assign_expression_stmt_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\nLine 20: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\",\"functionName\":\"constructor_obj_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_obj_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: constructor\n 18: CALL: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: data\n 13: ARG PASS: constructor(data) {\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = data;\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: obj\n 18: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\",\"functionName\":\"array_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\",\"functionName\":\"array_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\nLine 16: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\",\"functionName\":\"array_object_sensitive_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_005_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: push\n 13: CALL: s.push(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\",\"functionName\":\"map_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\",\"functionName\":\"map_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: set\n 13: CALL: map.set(__taint_src, \"value\");\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\",\"functionName\":\"map_object_sensitive_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_005_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\nLine 14: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\",\"functionName\":\"set_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: set\n 12: Var Pass: let set = new Set(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\nLine 15: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\",\"functionName\":\"set_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: add\n 13: CALL: set.add(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\",\"functionName\":\"exception_throw_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\",\"functionName\":\"exception_throw_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\nLine 15: __taint_sink(e)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\",\"functionName\":\"exception_throw_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_003_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_src\n 13: Throw Pass: throw __taint_src;\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\",\"functionName\":\"break_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\",\"functionName\":\"break_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\",\"functionName\":\"break_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\",\"functionName\":\"break_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_label_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_label_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\",\"functionName\":\"continue_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\",\"functionName\":\"continue_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\",\"functionName\":\"continue_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\nLine 16: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\",\"functionName\":\"return_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function return_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"some_condition\");\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\",\"functionName\":\"conditional_if_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\",\"functionName\":\"conditional_switch_no_solver_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_no_solver_004_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\",\"functionName\":\"conditional_if_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\",\"functionName\":\"conditional_if_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\",\"functionName\":\"conditional_switch_solver_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_solver_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\",\"functionName\":\"conditional_switch_solver_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_solver_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\",\"functionName\":\"for_body_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_body_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\",\"functionName\":\"while_body_solver_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function while_body_solver_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\nLine 16: __taint_sink(Reflect.get(obj, name))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\",\"functionName\":\"dynamic_call_reflect_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_002_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: name: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: get\n 16: CALL: __taint_sink(Reflect.get(obj, \"name\"));\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(Reflect.get(obj, \"name\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\nLine 17: __taint_sink(obj.foo)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\",\"functionName\":\"dynamic_call_reflect_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_003_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: set\n 16: CALL: Reflect.set(obj, \"foo\", __taint_src);\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: \n 16: Reflect.set Pass: Reflect.set(obj, \"foo\", __taint_src);\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(obj.foo);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\nLine 18: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\",\"functionName\":\"dynamic_call_reflect_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_005_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: data: __taint_src,\n 14: Var Pass: data1: \"aaa\",\n 15: Var Pass: };\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: deleteProperty\n 17: CALL: Reflect.deleteProperty(obj, \"data1\");\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\nLine 15: __taint_sink(a.value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\",\"functionName\":\"alias_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function alias_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: b.value\n 14: Var Pass: b.value = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(a.value);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\",\"functionName\":\"async_await_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: async function async_await_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: resolve\n 18: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\",\"functionName\":\"asynchronous_promise_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => {\n 18: CALL: __taint_sink(result);\n 19: CALL: })\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\nLine 18: __taint_sink(value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\",\"functionName\":\"asynchronous_promise_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: asyncFunc\n 18: CALL: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: value\n 12: ARG PASS: function asyncFunc(value) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: resolve\n 14: CALL: setTimeout(() => resolve(value), 10);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: \n 18: CALL: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: value\n 18: ARG PASS: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\",\"functionName\":\"asynchronous_promise_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => {\n 18: CALL: __taint_sink(result);\n 19: CALL: })\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\nLine 24: __taint_sink(final)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\",\"functionName\":\"asynchronous_promise_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => {\n 18: CALL: final = result;\n 19: CALL: })\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: final\n 18: Var Pass: final = result;\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: __taint_sink\n 24: SINK: __taint_sink(final);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\",\"functionName\":\"asynchronous_promise_009_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_009_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: [return value]\n 17: Return Value: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL RETURN: promise\n 17: CALL RETURN: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => result + \"_1\")\n 18: CALL: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: result\n 18: ARG PASS: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: [return value]\n 18: Return Value: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL RETURN: promise\n 17: CALL RETURN: .then((result) => result + \"_1\")\n 18: CALL RETURN: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => result + \"_1\")\n 18: CALL: .then((result) => result + \"_2\")\n 19: CALL: .then((result) => {\n 20: CALL: __taint_sink(result);\n 21: CALL: });\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: result\n 19: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\nLine 19: __taint_sink(error)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\",\"functionName\":\"asynchronous_promise_011_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_011_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: reject\n 13: CALL: reject(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => {})\n 18: CALL: .catch((error) => {\n 19: CALL: __taint_sink(error);\n 20: CALL: });\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: error\n 18: ARG PASS: .catch((error) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(error);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_012_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\nLine 26: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\",\"functionName\":\"asynchronous_promisify_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: __taint_src\n 22: SOURCE: async function asynchronous_promisify_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: data\n 25: Var Pass: let data = await readFileAsync(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\nLine 29: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\",\"functionName\":\"cross_class_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function cross_class_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: getData\n 24: CALL: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: new A()\n 24: ARG PASS: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: [return value]\n 18: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: getData\n 24: CALL RETURN: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: this.data\n 24: Var Pass: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: obj\n 28: Var Pass: let obj = new B();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\nLine 36: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\",\"functionName\":\"cross_class_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function cross_class_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: setData\n 35: CALL: b.setData(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: data\n 28: ARG PASS: setData(data) {\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: this.data\n 29: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: __taint_sink\n 36: SINK: __taint_sink(a);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\nLine 19: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\",\"functionName\":\"simple_object_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: constructor\n 18: CALL: let obj = new A(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: data\n 13: ARG PASS: constructor(data) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: obj\n 18: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\nLine 18: __taint_sink(person.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\",\"functionName\":\"simple_object_prototype_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_prototype_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: Person.prototype.name\n 14: Var Pass: Person.prototype.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: person\n 16: Var Pass: let person = new Person();\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(person.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\nLine 18: __taint_sink(person.__proto__.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\",\"functionName\":\"simple_object_prototype_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_prototype_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: Person.prototype.name\n 14: Var Pass: Person.prototype.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: person\n 16: Var Pass: let person = new Person();\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(person.__proto__.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\",\"functionName\":\"conditional_if_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\",\"functionName\":\"conditional_if_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\",\"functionName\":\"conditional_if_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\",\"functionName\":\"conditional_switch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\",\"functionName\":\"dowhile_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: res\n 14: Var Pass: res = res + __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: } while (__taint_sink(res));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\nLine 14: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\",\"functionName\":\"every_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function every_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: \n 13: CALL: arr.every(function (item) {\n 14: CALL: __taint_sink(item);\n 15: CALL: });\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: item\n 13: ARG PASS: arr.every(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\",\"functionName\":\"for_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\",\"functionName\":\"for_init_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_init_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: ini\n 15: Var Pass: for (ini = __taint_src; j < 10; j++) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: res\n 16: Var Pass: res = res + ini;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\",\"functionName\":\"for_update_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_update_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: j\n 15: Var Pass: for (; ini < 2; j = __taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: res\n 16: Var Pass: res = j;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\nLine 15: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\",\"functionName\":\"foreach_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function foreach_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: \n 14: CALL: arr.forEach(function (item) {\n 15: CALL: __taint_sink(item);\n 16: CALL: });\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: item\n 14: ARG PASS: arr.forEach(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\",\"functionName\":\"forin_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function forin_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = { key1: \"value1\", key2: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\",\"functionName\":\"forof_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function forof_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: value\n 14: Var Pass: for (let value of arr) {\n 15: Var Pass: res = value;\n 16: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = value;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\nLine 14: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\",\"functionName\":\"some_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function some_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: \n 13: CALL: arr.some(function (item) {\n 14: CALL: __taint_sink(item);\n 15: CALL: });\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: item\n 13: ARG PASS: arr.some(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\",\"functionName\":\"while_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function while_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = res + __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_001_T/A/cross_module_001_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_001_T/B/cross_module_001_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_002_F/A/cross_module_002_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_002_F/B/cross_module_002_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_003_T/A/cross_module_003_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_003_T/B/cross_module_003_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_004_F/A/cross_module_004_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_004_F/B/cross_module_004_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_005_T/A/cross_module_005_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_005_T/B/cross_module_005_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_006_F/A/cross_module_006_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_006_F/B/cross_module_006_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_007_T/A/cross_module_007_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_007_T/B/cross_module_007_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_008_F/A/cross_module_008_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_008_F/B/cross_module_008_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_009_T/A/cross_module_009_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_009_T/B/cross_module_009_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_010_F/A/cross_module_010_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_010_F/B/cross_module_010_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_011_T/A/cross_module_011_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_011_T/B/cross_module_011_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_012_F/A/cross_module_012_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_012_F/B/cross_module_012_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\nLine 13: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\",\"functionName\":\"array_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\nLine 13: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\",\"functionName\":\"array_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\",\"functionName\":\"array_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: push\n 13: CALL: s.push(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\nLine 13: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\",\"functionName\":\"set_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: set\n 12: Var Pass: let set = new Set(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\nLine 14: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\",\"functionName\":\"map_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/map/map_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\nLine 15: __taint_sink(e)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\",\"functionName\":\"exception_catch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_catch_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_src\n 13: Throw Pass: throw __taint_src;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\nLine 15: __taint_sink(e.message)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\",\"functionName\":\"exception_catch_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_catch_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: {message:__taint_src, code:123}\n 13: Throw Pass: throw { message: __taint_src, code: 123 };\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e.message);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\",\"functionName\":\"exception_finally_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_finally_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_src\n 14: Throw Pass: throw __taint_src;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: e\n 15: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: res\n 16: Var Pass: res = e;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\",\"functionName\":\"exception_try_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_try_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\",\"functionName\":\"assign_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function assign_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: result\n 13: Var Pass: result = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\",\"functionName\":\"binary_expression_add_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function binary_expression_add_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src + \"_\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\",\"functionName\":\"binary_expression_add_assignment_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function binary_expression_add_assignment_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\",\"functionName\":\"bitwise_expression_and_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_and_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src & 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\",\"functionName\":\"bitwise_expression_lsh_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_lsh_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src << 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\",\"functionName\":\"bitwise_expression_not_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_not_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\",\"functionName\":\"bitwise_expression_or_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_or_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src | 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\",\"functionName\":\"bitwise_expression_rsh_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_rsh_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src >> 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\",\"functionName\":\"bitwise_expression_xor_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_xor_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src ^ 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\",\"functionName\":\"logic_expression_and_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function logic_expression_and_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: result\n 12: Var Pass: let result = \"_\" && __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\",\"functionName\":\"logic_expression_or_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function logic_expression_or_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src || \"_\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\",\"functionName\":\"prefix_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function prefix_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\",\"functionName\":\"relation_expression_equal_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_equal_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src === \"taint_src_value\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\",\"functionName\":\"relation_expression_equal_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_equal_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src === \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\",\"functionName\":\"relation_expression_greater_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_greater_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src > \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\",\"functionName\":\"relation_expression_greater_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_greater_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src > \"taint_src_value\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\",\"functionName\":\"relation_expression_less_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_less_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src < \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\",\"functionName\":\"relation_expression_less_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_less_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src < \"taint_src_valueaa\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\",\"functionName\":\"suffix_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function suffix_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\",\"functionName\":\"conditional_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: result\n 13: Var Pass: result = true ? __taint_src : \"aa\";\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\",\"functionName\":\"lambda_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function lambda_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: \n 14: CALL: result = lambda(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: a\n 13: ARG PASS: const lambda = (a) => a;\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: [return value]\n 13: Return Value: const lambda = (a) => a;\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: \n 14: CALL RETURN: result = lambda(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: result\n 14: Var Pass: result = lambda(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\nLine 17: __taint_sink(Employee.lastname)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\",\"functionName\":\"delete_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function delete_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: Employee\n 11: Var Pass: const Employee = {\n 12: Var Pass: firstname: \"Bob\",\n 13: Var Pass: lastname: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(Employee.lastname);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\nLine 13: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\",\"functionName\":\"delete_expression_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function delete_expression_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: array\n 11: Var Pass: const array = [__taint_src, \"b\", \"c\", \"d\"];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(array);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\",\"functionName\":\"destructuring_assignment_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"_\", \"_\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: result\n 13: Var Pass: let [a, b, result] = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\",\"functionName\":\"destructuring_assignment_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = { a: \"_\", b: \"_\", c: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: c\n 13: Var Pass: let { a, b, c } = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\",\"functionName\":\"destructuring_assignment_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"_\", \"_\", [__taint_src, \"_\"]];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: c\n 13: Var Pass: let [a, b, [c, d]] = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\",\"functionName\":\"destructuring_assignment_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = { a: \"_\", b: \"_\", c: { __taint_src, d: \"a\" } };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: c\n 13: Var Pass: let { a, b, c } = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\",\"functionName\":\"exponentiation_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exponentiation_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src ** 2;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\",\"functionName\":\"nullish_coalescing_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function nullish_coalescing_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = null ?? __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\",\"functionName\":\"optional_chaining_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function optional_chaining_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: taintKey: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: result\n 16: Var Pass: let result = obj?.taintKey;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\nLine 16: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\",\"functionName\":\"rest_parameter_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs(\"prefix\", __taint_src, \"suffix\");\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args);\n 17: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\nLine 17: __taint_sink({with(params)})\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\",\"functionName\":\"rest_parameter_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: params\n 12: Var Pass: const params = {\n 13: Var Pass: name: \"Tony\",\n 14: Var Pass: age: \"12\",\n 15: Var Pass: id: __taint_src,\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink({ ...params });\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\nLine 16: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\",\"functionName\":\"rest_parameter_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs([\"prefix\", __taint_src, \"suffix\"]);\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args);\n 17: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\nLine 14: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\",\"functionName\":\"spread_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: array1\n 12: Var Pass: let array1 = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: array\n 13: Var Pass: let array = [\"c\", ...array1];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(array);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\nLine 21: __taint_sink(newParams)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\",\"functionName\":\"spread_operator_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: params\n 12: Var Pass: const params = {\n 13: Var Pass: name: \"Tony\",\n 14: Var Pass: age: \"12\",\n 15: Var Pass: id: __taint_src,\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: newParams\n 17: Var Pass: const newParams = {\n 18: Var Pass: score: 100,\n 19: Var Pass: ...params,\n 20: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink(newParams);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\nLine 15: __taint_sink(rest)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\",\"functionName\":\"spread_operator_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: foo\n 12: Var Pass: const foo = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __tmp2__\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: rest\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(rest);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\",\"functionName\":\"template_literal_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = `_${__taint_src}`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\",\"functionName\":\"template_literal_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: result\n 12: Var Pass: let result = `${__taint_src}_`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\",\"functionName\":\"template_literal_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: result\n 12: Var Pass: let result = `_${__taint_src}_`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\",\"functionName\":\"this_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function this_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: value: __taint_src,\n 14: Var Pass: getValue: function () {\n 15: Var Pass: return this.value;\n 16: Var Pass: },\n 17: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: \n 19: CALL: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: obj\n 19: ARG PASS: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return this.value;\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: \n 19: CALL RETURN: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: result\n 19: Var Pass: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\nLine 15: __taint_sink(this.result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\",\"functionName\":\"this_expression_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: __taint_src\n 13: SOURCE: function this_expression_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: this.result\n 14: Var Pass: this.result = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(this.result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\",\"functionName\":\"type_cast_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = Number(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\",\"functionName\":\"type_cast_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src == 5;\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\",\"functionName\":\"type_cast_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src == \"5\";\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\nLine 14: __taint_sink(process(__taint_src, foo))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\",\"functionName\":\"anonymous_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: \n 14: CALL: __taint_sink(process(__taint_src, \"foo\"));\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: a\n 11: ARG PASS: const process = function (a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: [return value]\n 12: Return Value: return a + b;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: \n 14: CALL RETURN: __taint_sink(process(__taint_src, \"foo\"));\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(process(__taint_src, \"foo\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\nLine 12: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\",\"functionName\":\"anonymous_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: \n 15: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: input\n 11: ARG PASS: let process = function (input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\",\"functionName\":\"anonymous_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\",\"functionName\":\"closure_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\",\"functionName\":\"closure_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\nLine 25: __taint_sink(a.update())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\",\"functionName\":\"closure_function_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: source\n 15: Var Pass: source = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: [return value]\n 16: Return Value: return source;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: \n 25: CALL RETURN: __taint_sink(a.update());\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink(a.update());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\nLine 18: __taint_sink(middleVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\",\"functionName\":\"closure_function_009_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_009_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: outerVar\n 12: Var Pass: let outerVar = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: middleVar\n 15: Var Pass: let middleVar = outerVar;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(middleVar);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\nLine 16: __taint_sink(outerVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\",\"functionName\":\"closure_function_011_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_011_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: outerVar\n 12: Var Pass: let outerVar = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(outerVar);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_012_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\nLine 14: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\",\"functionName\":\"closure_function_013_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_013_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: data\n 11: Var Pass: var data = {\n 12: Var Pass: name: __taint_src,\n 13: Var Pass: show: function () {\n 14: Var Pass: __taint_sink(this.name);\n 15: Var Pass: },\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: \n 17: CALL: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: data\n 17: ARG PASS: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_014_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\nLine 15: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\",\"functionName\":\"closure_function_015_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_015_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: data\n 11: Var Pass: var data = {\n 12: Var Pass: name: __taint_src,\n 13: Var Pass: show: function () {\n 14: Var Pass: return function () {\n 15: Var Pass: __taint_sink(this.name);\n 16: Var Pass: };\n 17: Var Pass: },\n 18: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: \n 19: CALL: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: data\n 19: ARG PASS: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: \n 19: CALL: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: data.show()\n 19: ARG PASS: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_016_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\nLine 14: __taint_sink(this.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\",\"functionName\":\"closure_function_017_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_017_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: Process\n 18: CALL: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: data\n 11: ARG PASS: function Process(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: this.data\n 12: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: p\n 18: Var Pass: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: \n 19: CALL: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: p\n 19: ARG PASS: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(this.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\nLine 15: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\",\"functionName\":\"argument_passing_default_value_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_default_value_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __tmp1__\n 14: ARG PASS: function process(input = \"default_value\") {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: input\n 14: Var Pass: function process(input = \"default_value\") {\n 15: Var Pass: __taint_sink(input);\n 16: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\nLine 15: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\",\"functionName\":\"argument_passing_normal_value_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_normal_value_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: arg\n 14: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\nLine 15: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\",\"functionName\":\"argument_passing_normal_value_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_normal_value_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\nLine 13: __taint_sink(innerInput)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\",\"functionName\":\"argument_passing_normal_value_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function argument_passing_normal_value_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: outer\n 19: CALL: outer(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: input\n 11: ARG PASS: function outer(input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: inner\n 16: CALL: inner(input);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: innerInput\n 12: ARG PASS: function inner(innerInput) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(innerInput);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\nLine 14: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\",\"functionName\":\"argument_passing_reference_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: obj.data\n 17: Var Pass: obj.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\nLine 14: __taint_sink(arr)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\",\"functionName\":\"argument_passing_reference_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: inputArr[0]\n 17: Var Pass: inputArr[0] = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(arr);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\nLine 16: __taint_sink(objB.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\",\"functionName\":\"argument_passing_reference_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: objA\n 12: Var Pass: const objA = { name: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: swap\n 15: CALL: swap(objA, objB);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: obj1\n 18: ARG PASS: function swap(obj1, obj2) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: temp\n 19: Var Pass: const temp = obj1.name;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: obj2.name\n 21: Var Pass: obj2.name = temp;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(objB.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\",\"functionName\":\"arrow_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: __taint_sink\n 12: SINK: let arrowFunction = () => __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\",\"functionName\":\"arrow_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\nLine 15: __taint_sink(self.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\",\"functionName\":\"arrow_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: this.name\n 12: Var Pass: this.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: __taint_sink\n 15: SINK: show: () => __taint_sink(self.name),\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\nLine 16: __taint_sink(self.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\",\"functionName\":\"arrow_function_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_008_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: this.name\n 12: Var Pass: this.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: __taint_sink\n 16: SINK: return () => __taint_sink(self.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\nLine 14: __taint_sink(this.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\",\"functionName\":\"arrow_function_010_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_010_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: Process\n 17: CALL: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: data\n 12: ARG PASS: function Process(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: this.data\n 13: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: p\n 17: Var Pass: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: \n 18: CALL: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: p\n 18: ARG PASS: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: __taint_sink\n 14: SINK: this.show = () => __taint_sink(this.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\nLine 28: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\",\"functionName\":\"chained_call_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function chained_call_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: setName\n 32: CALL: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: name\n 17: ARG PASS: setName(name) {\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: this.name\n 18: Var Pass: this.name = name;\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: [return value]\n 19: Return Value: return this;\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: setName\n 32: CALL RETURN: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: process\n 32: CALL: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: new A().setName(_).clearName().setName(__taint_src\n 32: ARG PASS: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: __taint_sink\n 28: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_004_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_member_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_member_decorator_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\nLine 14: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\",\"functionName\":\"function_decorator_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function function_decorator_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: \n 20: CALL: decoratedFunction(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __tmp1__\n 13: ARG PASS: return function (...args) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: args\n 13: Var Pass: return function (...args) {\n 14: Var Pass: __taint_sink(args);\n 15: Var Pass: return targetFunction.apply(this, args);\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\nLine 19: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\",\"functionName\":\"function_decorator_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function function_decorator_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: \n 21: CALL: decoratedFunction(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __tmp1__\n 13: ARG PASS: return function (...args) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: args\n 13: Var Pass: return function (...args) {\n 14: Var Pass: return targetFunction.apply(this, args);\n 15: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: \n 14: CALL: return targetFunction.apply(this, args);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: input\n 18: ARG PASS: const decoratedFunction = taintDecorator(function (input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\nLine 21: __taint_sink(g.next(__taint_src).value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\",\"functionName\":\"generator_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function generator_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink(g.next(__taint_src).value);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\nLine 19: __taint_sink(f(__taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\",\"functionName\":\"higher_order_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: f\n 19: CALL: __taint_sink(f(__taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: a\n 12: ARG PASS: function f(a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: [return value]\n 15: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: \n 19: CALL RETURN: __taint_sink(f(__taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(f(__taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\nLine 23: __taint_sink(f(g, __taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\",\"functionName\":\"higher_order_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: f\n 23: CALL: __taint_sink(f(g, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: a\n 12: ARG PASS: function f(g, a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: g\n 13: CALL: return g(a, b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: a\n 16: ARG PASS: function g(a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: [return value]\n 19: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: \n 23: CALL RETURN: __taint_sink(f(g, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink(f(g, __taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\nLine 27: __taint_sink(f(g, u, __taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\",\"functionName\":\"higher_order_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: f\n 27: CALL: __taint_sink(f(g, u, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: a\n 12: ARG PASS: function f(g, u, a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: g\n 13: CALL: return g(u, a, b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: a\n 16: ARG PASS: function g(u, a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: u\n 18: CALL: return u(a, b, c);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: a\n 21: ARG PASS: function u(a, b, c) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: [return value]\n 23: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: \n 27: CALL RETURN: __taint_sink(f(g, u, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(f(g, u, __taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\",\"functionName\":\"higher_order_function_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_008_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: \n 13: CALL: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: a\n 16: ARG PASS: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: [return value]\n 16: Return Value: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: \n 13: CALL RETURN: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: [return value]\n 13: Return Value: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: higherOrderFunction\n 16: CALL RETURN: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: result\n 16: Var Pass: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\",\"functionName\":\"higher_order_function_010_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_010_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: \n 13: CALL: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: a\n 16: ARG PASS: const result = higherOrderFunction(function (a, b) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: [return value]\n 17: Return Value: return a + b;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: \n 13: CALL RETURN: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: [return value]\n 13: Return Value: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: higherOrderFunction\n 16: CALL RETURN: const result = higherOrderFunction(function (a, b) {\n 17: CALL RETURN: return a + b;\n 18: CALL RETURN: });\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: result\n 16: Var Pass: const result = higherOrderFunction(function (a, b) {\n 17: Var Pass: return a + b;\n 18: Var Pass: });\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\nLine 15: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\",\"functionName\":\"json_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function json_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: process\n 11: CALL: process(JSON.stringify(__taint_src));\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: obj\n 14: Var Pass: let obj = JSON.parse(arg);\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\",\"functionName\":\"string_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function string_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: process\n 11: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: result\n 14: Var Pass: let result = arg.trim();\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\nLine 31: __taint_sink(this.getData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\",\"functionName\":\"constructor_extends_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function constructor_extends_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: constructor\n 35: CALL: const derived = new DerivedClass(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: data\n 26: ARG PASS: constructor(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: constructor\n 27: CALL: super(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: data\n 14: ARG PASS: constructor(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: this.data\n 15: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: derived\n 35: Var Pass: const derived = new DerivedClass(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: process\n 36: CALL: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: derived\n 36: ARG PASS: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: getData\n 31: CALL: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: this\n 31: ARG PASS: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: [return value]\n 19: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: getData\n 31: CALL RETURN: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: __taint_sink\n 31: SINK: __taint_sink(this.getData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\nLine 29: __taint_sink(this.getData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\",\"functionName\":\"constructor_extends_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function constructor_extends_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: this.data\n 13: Var Pass: this.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: derived\n 33: Var Pass: const derived = new DerivedClass();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: process\n 34: CALL: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: derived\n 34: ARG PASS: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: getData\n 29: CALL: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: this\n 29: ARG PASS: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: [return value]\n 17: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: getData\n 29: CALL RETURN: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink(this.getData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\nLine 26: __taint_sink(sub.call())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\",\"functionName\":\"polymorphism_override_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function polymorphism_override_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: call\n 26: CALL RETURN: __taint_sink(sub.call());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(sub.call());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\nLine 27: __taint_sink(instance.getChValue())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\",\"functionName\":\"prototype_extends_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function prototype_extends_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: this.chProperty\n 18: Var Pass: this.chProperty = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: instance\n 26: Var Pass: let instance = new Child();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: \n 27: CALL: __taint_sink(instance.getChValue());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: instance\n 27: ARG PASS: __taint_sink(instance.getChValue());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: [return value]\n 23: Return Value: return this.chProperty;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: \n 27: CALL RETURN: __taint_sink(instance.getChValue());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(instance.getChValue());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\",\"functionName\":\"return_normal_value_passing_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function return_normal_value_passing_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: [return value]\n 16: Return Value: return __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: process\n 12: CALL RETURN: let data = process();\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: data\n 12: Var Pass: let data = process();\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\nLine 13: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\",\"functionName\":\"static_method_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: __taint_src\n 17: SOURCE: function static_method_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: process\n 18: CALL: MyClass.process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: arg\n 12: ARG PASS: static process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/tagged_template_literals/tagged_template_literal_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/tagged_template_literals/tagged_template_literal_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\nLine 22: __taint_sink(o.GetData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\",\"functionName\":\"private_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function private_variable_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: data\n 13: Var Pass: #data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: o\n 21: Var Pass: let o = new A();\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: GetData\n 22: CALL: __taint_sink(o.GetData());\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: o\n 22: ARG PASS: __taint_sink(o.GetData());\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return this.#data;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: GetData\n 22: CALL RETURN: __taint_sink(o.GetData());\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: __taint_sink\n 22: SINK: __taint_sink(o.GetData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\nLine 16: __taint_sink(A.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\",\"functionName\":\"static_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function static_variable_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: data\n 13: Var Pass: static data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(A.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\nLine 27: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\",\"functionName\":\"static_variable_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function static_variable_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: data\n 13: Var Pass: static data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: data\n 26: Var Pass: const data = A.data;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_004_F":"======================== Findings ========================\nNo findings!\n=========================================================="} \ No newline at end of file +{"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\nLine 14: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\",\"functionName\":\"argument_passing_value_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function argument_passing_value_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: process\n 11: CALL: process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\nLine 15: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\",\"functionName\":\"argument_passing_value_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_value_003_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"_\");\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/argument_passing_value_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\nLine 12: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\",\"functionName\":\"return_value_passing_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function return_value_passing_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: process\n 11: CALL RETURN: let data = process();\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: data\n 11: Var Pass: let data = process();\n /jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_001_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/argument_return_value_passing/return_value_passing_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\nLine 13: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\",\"functionName\":\"multi_invoke_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function multi_invoke_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: [return value]\n 16: Return Value: return arg;\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: process\n 11: CALL RETURN: let a = process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: a\n 11: Var Pass: let a = process(__taint_src);\n /jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(a);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/multi_invoke/multi_invoke_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\nLine 26: __taint_sink(sub.call())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\",\"functionName\":\"polymorphism_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function polymorphism_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: call\n 26: CALL RETURN: __taint_sink(sub.call());\n /jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(sub.call());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/no_solver/polymorphism_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/solver/polymorphism_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/context_sensitive/polymorphism/solver/polymorphism_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\nLine 20: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\",\"functionName\":\"constructor_field_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_field_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: obj\n 19: Var Pass: let obj = new A();\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\nLine 20: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\",\"functionName\":\"constructor_field_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_field_004_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = param;\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: obj\n 19: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/field_sensitive/class/constructor_field_004_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\nLine 32: __taint_sink(a.b.c.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\",\"functionName\":\"field_len_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.data\n 26: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: a\n 31: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_001_T\n AffectedNodeName: __taint_sink\n 32: SINK: __taint_sink(a.b.c.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\nLine 52: __taint_sink(s1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\",\"functionName\":\"field_len_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.data\n 44: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.f\n 38: Var Pass: this.f = new F();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.e\n 32: Var Pass: this.e = new E();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.d\n 26: Var Pass: this.d = new D();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: a\n 49: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: s\n 50: Var Pass: const s = a.b.c;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: s1\n 51: Var Pass: const s1 = s.d.e.f.data;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_003_T\n AffectedNodeName: __taint_sink\n 52: SINK: __taint_sink(s1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\nLine 86: __taint_sink(a.b.c.d.e.f.g.h.i.j.k.l.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\",\"functionName\":\"field_len_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function field_len_005_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.data\n 80: Var Pass: this.data = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.l\n 74: Var Pass: this.l = new L();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.k\n 68: Var Pass: this.k = new K();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.j\n 62: Var Pass: this.j = new J();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.i\n 56: Var Pass: this.i = new I();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.h\n 50: Var Pass: this.h = new H();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.g\n 44: Var Pass: this.g = new G();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.f\n 38: Var Pass: this.f = new F();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.e\n 32: Var Pass: this.e = new E();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.d\n 26: Var Pass: this.d = new D();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.c\n 20: Var Pass: this.c = new C();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: this.b\n 14: Var Pass: this.b = new B();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: a\n 85: Var Pass: const a = new A();\n /jsbenchmark/accuracy/field_sensitive/class/field_len_005_T\n AffectedNodeName: __taint_sink\n 86: SINK: __taint_sink(a.b.c.d.e.f.g.h.i.j.k.l.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/class/field_len_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\nLine 13: __taint_sink(s.0.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\",\"functionName\":\"array_multidimensional_collection_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_multidimensional_collection_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[0][0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/multidimensional_collection/array_multidimensional_collection_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\nLine 13: __taint_sink(s.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\",\"functionName\":\"array_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\",\"functionName\":\"array_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/array_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\nLine 15: __taint_sink(map.get(key1))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\",\"functionName\":\"map_field_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.get(\"key1\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\nLine 17: __taint_sink(map.get(key2))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\",\"functionName\":\"map_field_sensitive_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_004_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: set\n 15: CALL: map.set(\"key2\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_004_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(map.get(\"key2\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\nLine 15: __taint_sink(map.values())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\",\"functionName\":\"map_field_sensitive_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_006_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_006_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.values());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\nLine 15: __taint_sink(map.keys())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\",\"functionName\":\"map_field_sensitive_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_field_sensitive_008_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: set\n 13: CALL: map.set(__taint_src, \"value1\");\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_008_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(map.keys());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/map_field_sensitive_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\nLine 16: __taint_sink(args.1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\",\"functionName\":\"rest_parameter_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs(\"prefix\", __taint_src, \"suffix\");\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args[1]);\n 17: Var Pass: }\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args[1]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/rest_parameter_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\nLine 15: __taint_sink(rest.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\",\"functionName\":\"spread_operator_no_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_no_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: foo\n 12: Var Pass: const foo = __taint_src;\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __tmp2__\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: rest\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(rest[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\nLine 14: __taint_sink(array.3)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\",\"functionName\":\"spread_operator_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: array1\n 12: Var Pass: let array1 = [\"a\", \"b\", __taint_src];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: array\n 13: Var Pass: let array = [\"c\", ...array1];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(array[3]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_no_solver/spread_operator_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\nLine 13: __taint_sink(s.1+1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\",\"functionName\":\"array_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [\"a\", \"b\", __taint_src, \"c\", \"d\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[1 + 1]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\nLine 13: __taint_sink(s.1+2)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\",\"functionName\":\"array_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: s\n 12: Var Pass: let s = [\"a\", \"b\", __taint_src, \"c\", \"d\"];\n /jsbenchmark/accuracy/field_sensitive/one_dimensional_collection/numeric_index_state_solver/array_solver_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s[1 + 2]);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\nLine 14: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\",\"functionName\":\"asynchronous_await_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: async function asynchronous_await_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: resolve\n 19: CALL: resolve(__taint_src);\n /jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/asynchronous/asynchronous_await_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\",\"functionName\":\"dowhile_body_loop_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_loop_stmt_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\nLine 14: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\",\"functionName\":\"dowhile_body_loop_stmt_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_loop_stmt_002_F(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/dowhile_body_loop_stmt_002_F\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\",\"functionName\":\"for_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\",\"functionName\":\"for_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_002_F(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_002_F\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\",\"functionName\":\"for_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_003_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: res\n 14: Var Pass: for (res = __taint_src; i < 1; i++) {\n /jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/loop_stmt/for_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\",\"functionName\":\"assign_expression_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function assign_expression_stmt_001_T(__taint_src) {\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src;\n /jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\nLine 20: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\",\"functionName\":\"constructor_obj_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function constructor_obj_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = data;\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: obj\n 18: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/class/constructor_obj_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/class/constructor_obj_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\",\"functionName\":\"array_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\",\"functionName\":\"array_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\nLine 16: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\",\"functionName\":\"array_object_sensitive_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_object_sensitive_005_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: push\n 13: CALL: s.push(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/array_object_sensitive_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\",\"functionName\":\"map_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\",\"functionName\":\"map_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: set\n 13: CALL: map.set(__taint_src, \"value\");\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\nLine 16: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\",\"functionName\":\"map_object_sensitive_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_object_sensitive_005_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/map_object_sensitive_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\nLine 14: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\",\"functionName\":\"set_object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_object_sensitive_001_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: set\n 12: Var Pass: let set = new Set(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\nLine 15: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\",\"functionName\":\"set_object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_object_sensitive_003_T(__taint_src) {\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: add\n 13: CALL: set.add(__taint_src);\n /jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/object_sensitive/collection/set_object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\",\"functionName\":\"exception_throw_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\",\"functionName\":\"exception_throw_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_002_F\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\nLine 15: __taint_sink(e)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\",\"functionName\":\"exception_throw_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_throw_003_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_src\n 13: Throw Pass: throw __taint_src;\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/accuracy/path_sensitive/exception_throw/exception_throw_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\",\"functionName\":\"break_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\",\"functionName\":\"break_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\",\"functionName\":\"break_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\",\"functionName\":\"break_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function break_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_002_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_label_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/break_label_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\",\"functionName\":\"continue_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n\n------------- 2: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\",\"functionName\":\"continue_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: CALL: __taint_sink(res);\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:2\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\",\"functionName\":\"continue_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function continue_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/continue_002_F\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\nLine 16: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\",\"functionName\":\"return_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function return_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"some_condition\");\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/explicit_jump_control/return_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\",\"functionName\":\"conditional_if_no_solver_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_no_solver_003_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: res\n 16: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_if_no_solver_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\",\"functionName\":\"conditional_switch_no_solver_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_no_solver_004_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/no_solver/conditional_switch_no_solver_004_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\",\"functionName\":\"conditional_if_solver_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_solver_001_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\",\"functionName\":\"conditional_if_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_if_solver_002_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\",\"functionName\":\"conditional_switch_solver_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_solver_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\nLine 18: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\",\"functionName\":\"conditional_switch_solver_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_solver_002_T(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: data\n 15: Var Pass: data = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/conditional_switch_solver_002_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\nLine 16: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\",\"functionName\":\"for_body_solver_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_body_solver_002_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: res\n 14: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/for_body_solver_002_F\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\",\"functionName\":\"while_body_solver_001_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function while_body_solver_001_F(__taint_src) {\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_001_F\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/accuracy/path_sensitive/loop_conditional_stmt/solver/while_body_solver_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\nLine 16: __taint_sink(Reflect.get(obj, name))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\",\"functionName\":\"dynamic_call_reflect_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_002_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: name: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: get\n 16: CALL: __taint_sink(Reflect.get(obj, \"name\"));\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(Reflect.get(obj, \"name\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\nLine 17: __taint_sink(obj.foo)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\",\"functionName\":\"dynamic_call_reflect_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_003_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: set\n 16: CALL: Reflect.set(obj, \"foo\", __taint_src);\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: \n 16: Reflect.set Pass: Reflect.set(obj, \"foo\", __taint_src);\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_003_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(obj.foo);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\nLine 18: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\",\"functionName\":\"dynamic_call_reflect_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dynamic_call_reflect_005_T(__taint_src) {\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: data: __taint_src,\n 14: Var Pass: data1: \"aaa\",\n 15: Var Pass: };\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: deleteProperty\n 17: CALL: Reflect.deleteProperty(obj, \"data1\");\n /jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_005_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\nLine 15: __taint_sink(a.value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\",\"functionName\":\"alias_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function alias_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: b.value\n 14: Var Pass: b.value = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/alias/alias_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(a.value);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\",\"functionName\":\"async_await_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: async function async_await_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: resolve\n 18: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/async_await_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\",\"functionName\":\"asynchronous_promise_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T.asynchronous_promise_001_T.\n 16: CALL: promise\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T.asynchronous_promise_001_T.\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\nLine 18: __taint_sink(value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\",\"functionName\":\"asynchronous_promise_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: asyncFunc\n 18: CALL: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: value\n 12: ARG PASS: function asyncFunc(value) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: resolve\n 14: CALL: setTimeout(() => resolve(value), 10);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: \n 18: CALL: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: value\n 18: ARG PASS: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: asyncFunc(__taint_src).then((value) => __taint_sink(value));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\",\"functionName\":\"asynchronous_promise_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T.asynchronous_promise_005_T.\n 16: CALL: promise\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T.asynchronous_promise_005_T.\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_005_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\nLine 24: __taint_sink(final)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\",\"functionName\":\"asynchronous_promise_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => {\n 18: CALL: final = result;\n 19: CALL: })\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: final\n 18: Var Pass: final = result;\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T.asynchronous_promise_007_T.\n 23: CALL: .finally(() => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T.asynchronous_promise_007_T.\n 23: ARG PASS: .finally(() => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_007_T\n AffectedNodeName: __taint_sink\n 24: SINK: __taint_sink(final);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\",\"functionName\":\"asynchronous_promise_009_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_009_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: resolve\n 13: CALL: resolve(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: result\n 17: ARG PASS: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: [return value]\n 17: Return Value: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL RETURN: promise\n 17: CALL RETURN: .then((result) => result + \"_1\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: [return value]\n 18: Return Value: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL RETURN: promise\n 17: CALL RETURN: .then((result) => result + \"_1\")\n 18: CALL RETURN: .then((result) => result + \"_2\")\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: \n 16: CALL: promise\n 17: CALL: .then((result) => result + \"_1\")\n 18: CALL: .then((result) => result + \"_2\")\n 19: CALL: .then((result) => {\n 20: CALL: __taint_sink(result);\n 21: CALL: });\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: result\n 19: ARG PASS: .then((result) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_009_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\nLine 19: __taint_sink(error)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\",\"functionName\":\"asynchronous_promise_011_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function asynchronous_promise_011_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: reject\n 13: CALL: reject(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T.asynchronous_promise_011_T.\n 16: CALL: promise\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T.asynchronous_promise_011_T.\n 18: ARG PASS: .catch((error) => {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_011_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(error);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promise_012_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\nLine 26: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\",\"functionName\":\"asynchronous_promisify_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: __taint_src\n 22: SOURCE: async function asynchronous_promisify_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: data\n 25: Var Pass: let data = await readFileAsync(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_promisify_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\nLine 29: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\",\"functionName\":\"cross_class_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function cross_class_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: [return value]\n 18: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: getData\n 24: CALL RETURN: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: this.data\n 24: Var Pass: this.data = new A().getData();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: obj\n 28: Var Pass: let obj = new B();\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_001_T\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\nLine 36: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\",\"functionName\":\"cross_class_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function cross_class_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: this.data\n 29: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_003_T\n AffectedNodeName: __taint_sink\n 36: SINK: __taint_sink(a);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/complex_object/cross_class_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\nLine 19: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\",\"functionName\":\"simple_object_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: this.data\n 14: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: obj\n 18: Var Pass: let obj = new A(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\nLine 18: __taint_sink(person.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\",\"functionName\":\"simple_object_prototype_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_prototype_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: Person.prototype.name\n 14: Var Pass: Person.prototype.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: person\n 16: Var Pass: let person = new Person();\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(person.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\nLine 18: __taint_sink(person.__proto__.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\",\"functionName\":\"simple_object_prototype_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function simple_object_prototype_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: Person.prototype.name\n 14: Var Pass: Person.prototype.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: person\n 16: Var Pass: let person = new Person();\n /jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_003_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(person.__proto__.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/class/simple_object/simple_object_prototype_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\",\"functionName\":\"conditional_if_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\",\"functionName\":\"conditional_if_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\",\"functionName\":\"conditional_if_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_if_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\",\"functionName\":\"conditional_switch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_switch_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\nLine 15: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\",\"functionName\":\"dowhile_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function dowhile_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: res\n 14: Var Pass: res = res + __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: } while (__taint_sink(res));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/dowhile_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\nLine 14: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\",\"functionName\":\"every_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function every_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T.every_001_T.\n 13: CALL: arr.every(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T.every_001_T.\n 13: ARG PASS: arr.every(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/every_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\",\"functionName\":\"for_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\",\"functionName\":\"for_init_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_init_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: ini\n 15: Var Pass: for (ini = __taint_src; j < 10; j++) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: res\n 16: Var Pass: res = res + ini;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_init_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\",\"functionName\":\"for_update_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function for_update_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: j\n 15: Var Pass: for (; ini < 2; j = __taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: res\n 16: Var Pass: res = j;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/for_update_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\nLine 15: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\",\"functionName\":\"foreach_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function foreach_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T.foreach_001_T.\n 14: CALL: arr.forEach(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T.foreach_001_T.\n 14: ARG PASS: arr.forEach(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/foreach_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\",\"functionName\":\"forin_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function forin_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = { key1: \"value1\", key2: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_001_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forin_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\",\"functionName\":\"forof_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function forof_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: value\n 14: Var Pass: for (let value of arr) {\n 15: Var Pass: res = value;\n 16: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = value;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/forof_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\nLine 14: __taint_sink(item)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\",\"functionName\":\"some_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function some_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T.some_001_T.\n 13: CALL: arr.some(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T.some_001_T.\n 13: ARG PASS: arr.some(function (item) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(item);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/some_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\",\"functionName\":\"while_body_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function while_body_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: res\n 15: Var Pass: res = res + __taint_src;\n /jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/control_flow/loop_stmt/while_body_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_001_T/A/cross_module_001_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_001_T/B/cross_module_001_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_002_F/A/cross_module_002_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_002_F/B/cross_module_002_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_003_T/A/cross_module_003_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_003_T/B/cross_module_003_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_004_F/A/cross_module_004_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_004_F/B/cross_module_004_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_005_T/A/cross_module_005_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_005_T/B/cross_module_005_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_006_F/A/cross_module_006_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_006_F/B/cross_module_006_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_007_T/A/cross_module_007_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_007_T/B/cross_module_007_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_008_F/A/cross_module_008_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_008_F/B/cross_module_008_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_009_T/A/cross_module_009_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_009_T/B/cross_module_009_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_010_F/A/cross_module_010_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_010_F/B/cross_module_010_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_011_T/A/cross_module_011_T_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_011_T/B/cross_module_011_T_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_012_F/A/cross_module_012_F_a":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/cross_file_package_namespace/cross_module/cross_module_012_F/B/cross_module_012_F_b":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\nLine 13: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\",\"functionName\":\"array_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: s\n 12: Var Pass: let s = [__taint_src, \"b\", \"c\"];\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\nLine 13: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\",\"functionName\":\"array_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: s\n 12: Var Pass: let s = [[__taint_src], [\"b\"], \"c\"];\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\nLine 14: __taint_sink(s)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\",\"functionName\":\"array_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function array_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: push\n 13: CALL: s.push(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/array/array_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(s);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/array/array_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\nLine 13: __taint_sink(set)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\",\"functionName\":\"set_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function set_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: set\n 12: Var Pass: let set = new Set(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/collections/set_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(set);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/collections/set_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\nLine 14: __taint_sink(map)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\",\"functionName\":\"map_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function map_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: set\n 13: CALL: map.set(\"key1\", __taint_src);\n /jsbenchmark/completeness/single_app_tracing/datatype/map/map_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(map);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/datatype/map/map_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\nLine 15: __taint_sink(e)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\",\"functionName\":\"exception_catch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_catch_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_src\n 13: Throw Pass: throw __taint_src;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\nLine 15: __taint_sink(e.message)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\",\"functionName\":\"exception_catch_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_catch_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: {message:__taint_src, code:123}\n 13: Throw Pass: throw { message: __taint_src, code: 123 };\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: e\n 14: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(e.message);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_catch_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\",\"functionName\":\"exception_finally_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_finally_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_src\n 14: Throw Pass: throw __taint_src;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: e\n 15: Var Pass: } catch (e) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: res\n 16: Var Pass: res = e;\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_001_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(res);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_finally_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\",\"functionName\":\"exception_try_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exception_try_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/exception_error/exception_throw/exception_try_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\",\"functionName\":\"assign_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function assign_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: result\n 13: Var Pass: result = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\",\"functionName\":\"binary_expression_add_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function binary_expression_add_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src + \"_\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\",\"functionName\":\"binary_expression_add_assignment_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function binary_expression_add_assignment_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\",\"functionName\":\"bitwise_expression_and_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_and_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src & 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\",\"functionName\":\"bitwise_expression_lsh_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_lsh_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src << 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\",\"functionName\":\"bitwise_expression_not_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_not_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\",\"functionName\":\"bitwise_expression_or_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_or_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src | 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\",\"functionName\":\"bitwise_expression_rsh_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_rsh_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src >> 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\",\"functionName\":\"bitwise_expression_xor_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function bitwise_expression_xor_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src ^ 1;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\",\"functionName\":\"logic_expression_and_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function logic_expression_and_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: result\n 12: Var Pass: let result = \"_\" && __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\",\"functionName\":\"logic_expression_or_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function logic_expression_or_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src || \"_\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\",\"functionName\":\"prefix_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function prefix_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/prefix_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\",\"functionName\":\"relation_expression_equal_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_equal_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src === \"taint_src_value\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\",\"functionName\":\"relation_expression_equal_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_equal_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src === \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\",\"functionName\":\"relation_expression_greater_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_greater_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src > \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\",\"functionName\":\"relation_expression_greater_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_greater_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src > \"taint_src_value\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\",\"functionName\":\"relation_expression_less_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_less_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src < \"__taint_src\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\",\"functionName\":\"relation_expression_less_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: __taint_src\n 11: SOURCE: function relation_expression_less_002_F(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src < \"taint_src_valueaa\";\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\",\"functionName\":\"suffix_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function suffix_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/basic_expression_operation/suffix_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\",\"functionName\":\"conditional_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function conditional_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: result\n 13: Var Pass: result = true ? __taint_src : \"aa\";\n /jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\",\"functionName\":\"lambda_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function lambda_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: [return value]\n 13: Return Value: const lambda = (a) => a;\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: \n 14: CALL RETURN: result = lambda(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: result\n 14: Var Pass: result = lambda(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\nLine 17: __taint_sink(Employee.lastname)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\",\"functionName\":\"delete_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function delete_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: Employee\n 11: Var Pass: const Employee = {\n 12: Var Pass: firstname: \"Bob\",\n 13: Var Pass: lastname: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(Employee.lastname);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\nLine 13: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\",\"functionName\":\"delete_expression_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function delete_expression_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: array\n 11: Var Pass: const array = [__taint_src, \"b\", \"c\", \"d\"];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(array);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/delete_expression_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\",\"functionName\":\"destructuring_assignment_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"_\", \"_\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: result\n 13: Var Pass: let [a, b, result] = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\",\"functionName\":\"destructuring_assignment_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = { a: \"_\", b: \"_\", c: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: c\n 13: Var Pass: let { a, b, c } = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\",\"functionName\":\"destructuring_assignment_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = [\"_\", \"_\", [__taint_src, \"_\"]];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: c\n 13: Var Pass: let [a, b, [c, d]] = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\nLine 14: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\",\"functionName\":\"destructuring_assignment_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function destructuring_assignment_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: arr\n 12: Var Pass: let arr = { a: \"_\", b: \"_\", c: { __taint_src, d: \"a\" } };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: c\n 13: Var Pass: let { a, b, c } = arr;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_007_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(c);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\",\"functionName\":\"exponentiation_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function exponentiation_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src ** 2;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\",\"functionName\":\"nullish_coalescing_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function nullish_coalescing_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = null ?? __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/nullish_coalescing_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\",\"functionName\":\"optional_chaining_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function optional_chaining_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: taintKey: __taint_src,\n 14: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: result\n 16: Var Pass: let result = obj?.taintKey;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_001_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/optional_chaining_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\nLine 16: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\",\"functionName\":\"rest_parameter_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs(\"prefix\", __taint_src, \"suffix\");\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args);\n 17: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\nLine 17: __taint_sink({with(params)})\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\",\"functionName\":\"rest_parameter_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: params\n 12: Var Pass: const params = {\n 13: Var Pass: name: \"Tony\",\n 14: Var Pass: age: \"12\",\n 15: Var Pass: id: __taint_src,\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_003_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink({ ...params });\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\nLine 16: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\",\"functionName\":\"rest_parameter_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function rest_parameter_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: collectArgs\n 12: CALL: collectArgs([\"prefix\", __taint_src, \"suffix\"]);\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __tmp1__\n 15: ARG PASS: function collectArgs(...args) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: args\n 15: Var Pass: function collectArgs(...args) {\n 16: Var Pass: __taint_sink(args);\n 17: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_005_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/rest_parameter_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\nLine 14: __taint_sink(array)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\",\"functionName\":\"spread_operator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: array1\n 12: Var Pass: let array1 = [\"a\", \"b\", __taint_src];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: array\n 13: Var Pass: let array = [\"c\", ...array1];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(array);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\nLine 21: __taint_sink(newParams)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\",\"functionName\":\"spread_operator_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: params\n 12: Var Pass: const params = {\n 13: Var Pass: name: \"Tony\",\n 14: Var Pass: age: \"12\",\n 15: Var Pass: id: __taint_src,\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: newParams\n 17: Var Pass: const newParams = {\n 18: Var Pass: score: 100,\n 19: Var Pass: ...params,\n 20: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink(newParams);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\nLine 15: __taint_sink(rest)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\",\"functionName\":\"spread_operator_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function spread_operator_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: foo\n 12: Var Pass: const foo = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __tmp2__\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: rest\n 14: Var Pass: const [r1, r2, ...rest] = [123, 456, foo, bar];\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(rest);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/spread_operator_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\",\"functionName\":\"template_literal_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = `_${__taint_src}`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\",\"functionName\":\"template_literal_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: result\n 12: Var Pass: let result = `${__taint_src}_`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\",\"functionName\":\"template_literal_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function template_literal_005_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: result\n 12: Var Pass: let result = `_${__taint_src}_`;\n /jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_005_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/special_expression/template_literal_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\",\"functionName\":\"this_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function this_expression_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: obj\n 12: Var Pass: let obj = {\n 13: Var Pass: value: __taint_src,\n 14: Var Pass: getValue: function () {\n 15: Var Pass: return this.value;\n 16: Var Pass: },\n 17: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return this.value;\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: \n 19: CALL RETURN: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: result\n 19: Var Pass: let result = obj.getValue();\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_001_T\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\nLine 15: __taint_sink(this.result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\",\"functionName\":\"this_expression_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: __taint_src\n 13: SOURCE: function this_expression_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: this.result\n 14: Var Pass: this.result = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_003_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(this.result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/this_expression/this_expression_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\",\"functionName\":\"type_cast_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: result\n 12: Var Pass: let result = Number(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\",\"functionName\":\"type_cast_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src == 5;\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_003_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\",\"functionName\":\"type_cast_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function type_cast_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: result\n 12: Var Pass: let result = __taint_src == \"5\";\n /jsbenchmark/completeness/single_app_tracing/expression/type_cast/type_cast_004_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\nLine 14: __taint_sink(process(__taint_src, foo))\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\",\"functionName\":\"anonymous_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: [return value]\n 12: Return Value: return a + b;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: \n 14: CALL RETURN: __taint_sink(process(__taint_src, \"foo\"));\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(process(__taint_src, \"foo\"));\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\nLine 12: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\",\"functionName\":\"anonymous_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: \n 15: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: input\n 11: ARG PASS: let process = function (input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\",\"functionName\":\"anonymous_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function anonymous_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.anonymous_function_006_T.\n 11: CALL: (function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.anonymous_function_006_T.\n 11: ARG PASS: (function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\",\"functionName\":\"closure_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T.closure_function_002_T.\n 14: CALL: closure();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T.closure_function_002_T.\n 11: ARG PASS: let closure = function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_002_T\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\nLine 13: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\",\"functionName\":\"closure_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: inner\n 18: CALL: innerFunction();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: inner\n 12: ARG PASS: return function inner() {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_004_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\nLine 25: __taint_sink(a.update())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\",\"functionName\":\"closure_function_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_007_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: source\n 15: Var Pass: source = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: [return value]\n 16: Return Value: return source;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: \n 25: CALL RETURN: __taint_sink(a.update());\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_007_T\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink(a.update());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\nLine 18: __taint_sink(middleVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\",\"functionName\":\"closure_function_009_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_009_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: outerVar\n 12: Var Pass: let outerVar = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: middleVar\n 15: Var Pass: let middleVar = outerVar;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: inner\n 25: CALL: innerFunction();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: inner\n 17: ARG PASS: return function inner() {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_009_T\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink(middleVar);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_010_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\nLine 16: __taint_sink(outerVar)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\",\"functionName\":\"closure_function_011_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_011_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: outerVar\n 12: Var Pass: let outerVar = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: inner\n 23: CALL: innerFunction();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: inner\n 15: ARG PASS: return function inner() {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_011_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(outerVar);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_012_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\nLine 14: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\",\"functionName\":\"closure_function_013_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_013_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: data\n 11: Var Pass: var data = {\n 12: Var Pass: name: __taint_src,\n 13: Var Pass: show: function () {\n 14: Var Pass: __taint_sink(this.name);\n 15: Var Pass: },\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: \n 17: CALL: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: data\n 17: ARG PASS: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T.closure_function_013_T.\n 17: CALL: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T.closure_function_013_T.\n 13: ARG PASS: show: function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_013_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_014_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\nLine 15: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\",\"functionName\":\"closure_function_015_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_015_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: data\n 11: Var Pass: var data = {\n 12: Var Pass: name: __taint_src,\n 13: Var Pass: show: function () {\n 14: Var Pass: return function () {\n 15: Var Pass: __taint_sink(this.name);\n 16: Var Pass: };\n 17: Var Pass: },\n 18: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: \n 19: CALL: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: data\n 19: ARG PASS: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T.closure_function_015_T..\n 19: CALL: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T.closure_function_015_T..\n 14: ARG PASS: return function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_015_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_016_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\nLine 14: __taint_sink(this.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\",\"functionName\":\"closure_function_017_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function closure_function_017_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: Process\n 18: CALL: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: data\n 11: ARG PASS: function Process(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: this.data\n 12: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: p\n 18: Var Pass: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T.closure_function_017_T.Process.Process_scope.\n 19: CALL: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T.closure_function_017_T.Process.Process_scope.\n 13: ARG PASS: this.show = function () {\n /jsbenchmark/completeness/single_app_tracing/function_call/anonymous_function_closure/closure_function_017_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(this.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\nLine 15: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\",\"functionName\":\"argument_passing_default_value_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_default_value_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __tmp1__\n 14: ARG PASS: function process(input = \"default_value\") {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: input\n 14: Var Pass: function process(input = \"default_value\") {\n 15: Var Pass: __taint_sink(input);\n 16: Var Pass: }\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_default_value_002_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\nLine 15: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\",\"functionName\":\"argument_passing_normal_value_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_normal_value_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: arg\n 14: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\nLine 15: __taint_sink(arg1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\",\"functionName\":\"argument_passing_normal_value_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_normal_value_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: process\n 12: CALL: process(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: arg1\n 14: ARG PASS: function process(arg1, arg2) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_004_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(arg1);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\nLine 13: __taint_sink(innerInput)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\",\"functionName\":\"argument_passing_normal_value_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function argument_passing_normal_value_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: outer\n 19: CALL: outer(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: input\n 11: ARG PASS: function outer(input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: inner\n 16: CALL: inner(input);\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: innerInput\n 12: ARG PASS: function inner(innerInput) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_006_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(innerInput);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\nLine 14: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\",\"functionName\":\"argument_passing_reference_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: obj.data\n 17: Var Pass: obj.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(obj.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\nLine 14: __taint_sink(arr)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\",\"functionName\":\"argument_passing_reference_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: inputArr[0]\n 17: Var Pass: inputArr[0] = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(arr);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\nLine 16: __taint_sink(objB.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\",\"functionName\":\"argument_passing_reference_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function argument_passing_reference_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: objA\n 12: Var Pass: const objA = { name: __taint_src };\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: temp\n 19: Var Pass: const temp = obj1.name;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: obj2.name\n 21: Var Pass: obj2.name = temp;\n /jsbenchmark/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(objB.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\nLine 12: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\",\"functionName\":\"arrow_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T.arrow_function_002_T.\n 13: CALL: arrowFunction();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T.arrow_function_002_T.\n 12: ARG PASS: let arrowFunction = () => __taint_sink(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_002_T\n AffectedNodeName: __taint_sink\n 12: SINK: let arrowFunction = () => __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\nLine 14: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\",\"functionName\":\"arrow_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T.arrow_function_004_T..\n 19: CALL: innerFunction();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T.arrow_function_004_T..\n 13: ARG PASS: return () => {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_004_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\nLine 15: __taint_sink(self.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\",\"functionName\":\"arrow_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: this.name\n 12: Var Pass: this.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T.arrow_function_006_T.\n 17: CALL: data.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T.arrow_function_006_T.\n 15: ARG PASS: show: () => __taint_sink(self.name),\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_006_T\n AffectedNodeName: __taint_sink\n 15: SINK: show: () => __taint_sink(self.name),\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\nLine 16: __taint_sink(self.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\",\"functionName\":\"arrow_function_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_008_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: this.name\n 12: Var Pass: this.name = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T.arrow_function_008_T..\n 19: CALL: data.show().call(data);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T.arrow_function_008_T..\n 16: ARG PASS: return () => __taint_sink(self.name);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_008_T\n AffectedNodeName: __taint_sink\n 16: SINK: return () => __taint_sink(self.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\nLine 14: __taint_sink(this.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\",\"functionName\":\"arrow_function_010_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function arrow_function_010_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: Process\n 17: CALL: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: data\n 12: ARG PASS: function Process(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: this.data\n 13: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: p\n 17: Var Pass: const p = new Process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T.arrow_function_010_T.Process.Process_scope.\n 18: CALL: p.show();\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T.arrow_function_010_T.Process.Process_scope.\n 14: ARG PASS: this.show = () => __taint_sink(this.data);\n /jsbenchmark/completeness/single_app_tracing/function_call/arrow_function/arrow_function_010_T\n AffectedNodeName: __taint_sink\n 14: SINK: this.show = () => __taint_sink(this.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\nLine 28: __taint_sink(this.name)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\",\"functionName\":\"chained_call_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function chained_call_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: setName\n 32: CALL: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: name\n 17: ARG PASS: setName(name) {\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: this.name\n 18: Var Pass: this.name = name;\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: [return value]\n 19: Return Value: return this;\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: setName\n 32: CALL RETURN: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: process\n 32: CALL: new A().setName(\"_\").clearName().setName(__taint_src).process();\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: process\n 27: ARG PASS: process() {\n /jsbenchmark/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T\n AffectedNodeName: __taint_sink\n 28: SINK: __taint_sink(this.name);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_decorator_004_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_member_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/class_member_decorator_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\nLine 14: __taint_sink(args)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\",\"functionName\":\"function_decorator_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function function_decorator_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: \n 20: CALL: decoratedFunction(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __tmp1__\n 13: ARG PASS: return function (...args) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: args\n 13: Var Pass: return function (...args) {\n 14: Var Pass: __taint_sink(args);\n 15: Var Pass: return targetFunction.apply(this, args);\n 16: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_002_T\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink(args);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\nLine 19: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\",\"functionName\":\"function_decorator_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function function_decorator_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: \n 21: CALL: decoratedFunction(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __tmp1__\n 13: ARG PASS: return function (...args) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: args\n 13: Var Pass: return function (...args) {\n 14: Var Pass: return targetFunction.apply(this, args);\n 15: Var Pass: };\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T.function_decorator_004_T.\n 14: CALL: return targetFunction.apply(this, args);\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T.function_decorator_004_T.\n 18: ARG PASS: const decoratedFunction = taintDecorator(function (input) {\n /jsbenchmark/completeness/single_app_tracing/function_call/decorator_function/function_decorator_004_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(input);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\nLine 21: __taint_sink(g.next(__taint_src).value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\",\"functionName\":\"generator_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function generator_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/generator_function/generator_function_004_T\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink(g.next(__taint_src).value);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\nLine 19: __taint_sink(f(__taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\",\"functionName\":\"higher_order_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: [return value]\n 15: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: \n 19: CALL RETURN: __taint_sink(f(__taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(f(__taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\nLine 23: __taint_sink(f(g, __taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\",\"functionName\":\"higher_order_function_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_004_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: [return value]\n 19: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: \n 23: CALL RETURN: __taint_sink(f(g, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink(f(g, __taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\nLine 27: __taint_sink(f(g, u, __taint_src, _)())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\",\"functionName\":\"higher_order_function_006_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_006_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: [return value]\n 23: Return Value: return a + b + c;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: \n 27: CALL RETURN: __taint_sink(f(g, u, __taint_src, \"_\")());\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(f(g, u, __taint_src, \"_\")());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_007_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\",\"functionName\":\"higher_order_function_008_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_008_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: [return value]\n 16: Return Value: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: \n 13: CALL RETURN: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: [return value]\n 13: Return Value: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: higherOrderFunction\n 16: CALL RETURN: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: result\n 16: Var Pass: const result = higherOrderFunction((a, b) => a + b);\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_009_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\",\"functionName\":\"higher_order_function_010_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function higher_order_function_010_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: [return value]\n 17: Return Value: return a + b;\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: \n 13: CALL RETURN: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: [return value]\n 13: Return Value: return callback(__taint_src, \"_\");\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: higherOrderFunction\n 16: CALL RETURN: const result = higherOrderFunction(function (a, b) {\n 17: CALL RETURN: return a + b;\n 18: CALL RETURN: });\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: result\n 16: Var Pass: const result = higherOrderFunction(function (a, b) {\n 17: Var Pass: return a + b;\n 18: Var Pass: });\n /jsbenchmark/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\nLine 15: __taint_sink(obj)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\",\"functionName\":\"json_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function json_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: process\n 11: CALL: process(JSON.stringify(__taint_src));\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: obj\n 14: Var Pass: let obj = JSON.parse(arg);\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(obj);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/json_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\",\"functionName\":\"string_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function string_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: process\n 11: CALL: process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: arg\n 13: ARG PASS: function process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: result\n 14: Var Pass: let result = arg.trim();\n /jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_001_T\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink(result);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/library_function/string_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\nLine 31: __taint_sink(this.getData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\",\"functionName\":\"constructor_extends_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function constructor_extends_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: constructor\n 35: CALL: const derived = new DerivedClass(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: data\n 26: ARG PASS: constructor(data) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: this.data\n 15: Var Pass: this.data = data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: derived\n 35: Var Pass: const derived = new DerivedClass(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: [return value]\n 19: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: process\n 36: CALL: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: process\n 30: ARG PASS: process() {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: getData\n 31: CALL RETURN: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_001_T\n AffectedNodeName: __taint_sink\n 31: SINK: __taint_sink(this.getData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\nLine 29: __taint_sink(this.getData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\",\"functionName\":\"constructor_extends_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function constructor_extends_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: this.data\n 13: Var Pass: this.data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: derived\n 33: Var Pass: const derived = new DerivedClass();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: process\n 34: CALL: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: derived\n 34: ARG PASS: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: [return value]\n 17: Return Value: return this.data;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: process\n 34: CALL: derived.process();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: process\n 28: ARG PASS: process() {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: getData\n 29: CALL RETURN: __taint_sink(this.getData());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_003_T\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink(this.getData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/constructor_extends_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\nLine 26: __taint_sink(sub.call())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\",\"functionName\":\"polymorphism_override_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function polymorphism_override_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: call\n 26: CALL RETURN: __taint_sink(sub.call());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_001_T\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink(sub.call());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/polymorphism_override_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\nLine 27: __taint_sink(instance.getChValue())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\",\"functionName\":\"prototype_extends_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: __taint_src\n 10: SOURCE: function prototype_extends_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: this.chProperty\n 18: Var Pass: this.chProperty = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: instance\n 26: Var Pass: let instance = new Child();\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: [return value]\n 23: Return Value: return this.chProperty;\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: \n 27: CALL RETURN: __taint_sink(instance.getChValue());\n /jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_001_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(instance.getChValue());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/override/prototype_extends_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\nLine 13: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\",\"functionName\":\"return_normal_value_passing_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function return_normal_value_passing_002_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: [return value]\n 16: Return Value: return __taint_src;\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: process\n 12: CALL RETURN: let data = process();\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: data\n 12: Var Pass: let data = process();\n /jsbenchmark/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_002_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\nLine 13: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\",\"functionName\":\"static_method_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: __taint_src\n 17: SOURCE: function static_method_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: process\n 18: CALL: MyClass.process(__taint_src);\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: arg\n 12: ARG PASS: static process(arg) {\n /jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_001_T\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink(arg);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/static_method/static_method_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/tagged_template_literals/tagged_template_literal_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/function_call/tagged_template_literals/tagged_template_literal_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\nLine 22: __taint_sink(o.GetData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\",\"functionName\":\"private_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function private_variable_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: data\n 13: Var Pass: #data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: o\n 21: Var Pass: let o = new A();\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: [return value]\n 15: Return Value: return this.#data;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: GetData\n 22: CALL RETURN: __taint_sink(o.GetData());\n /jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_001_T\n AffectedNodeName: __taint_sink\n 22: SINK: __taint_sink(o.GetData());\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/private_scope/private_variable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\nLine 16: __taint_sink(A.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\",\"functionName\":\"static_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function static_variable_001_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: data\n 13: Var Pass: static data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_001_T\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink(A.data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\nLine 27: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\",\"functionName\":\"static_variable_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: __taint_src\n 11: SOURCE: function static_variable_003_T(__taint_src) {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: data\n 13: Var Pass: static data = __taint_src;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: processA\n 32: CALL: a.processA();\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: processA\n 15: ARG PASS: processA() {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: test\n 16: CALL: this.test();\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: test\n 19: ARG PASS: test() {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: processB\n 20: CALL: new B().processB();\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: processB\n 25: ARG PASS: processB() {\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: data\n 26: Var Pass: const data = A.data;\n /jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_003_T\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink(data);\n==========================================================\n #Total-findings:1\n==========================================================","/jsbenchmark/completeness/single_app_tracing/variable_scope/static_variable/static_variable_004_F":"======================== Findings ========================\nNo findings!\n=========================================================="} \ No newline at end of file diff --git a/test/javascript/prepare-js-benchmark.ts b/test/javascript/prepare-js-benchmark.ts index 5f187575..c8b02942 100644 --- a/test/javascript/prepare-js-benchmark.ts +++ b/test/javascript/prepare-js-benchmark.ts @@ -18,6 +18,14 @@ interface BenchmarkRepoUrls { } const JS_ALL_BENCHMARK_REPO_URLS: BenchmarkRepoUrls = { + yasaNodeJsBenchmark: { + gitRepoUrl: 'git@code.alipay.com:jiufo_test/yasaNodeJsBenchmark.git', + branch: 'master', + }, + chairbenchmark: { + gitRepoUrl: 'git@code.alipay.com:jiufo_test/chairbenchmark.git', + branch: 'master', + }, jsbenchmark: { gitRepoUrl: XAST_JS_BENCHMARK_REPO_URL, branch: 'main-forYasaTest', diff --git a/test/javascript/test-egg-benchmark.ts b/test/javascript/test-egg-benchmark.ts new file mode 100644 index 00000000..de189f8e --- /dev/null +++ b/test/javascript/test-egg-benchmark.ts @@ -0,0 +1,203 @@ +import * as path from 'path' +import { describe, it } from 'mocha' +// @ts-ignore +import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' +const { execute } = require('../../src/interface/starter') +const { ErrorCode } = require('../../src/util/error-code') +const { + BENCHMARKS_DIR, + XAST_JS_BENCHMARK, + recordFindingStr, + readExpectRes, + resolveFindingResult, + getExpectResultPath, +} = require('../test-utils') +import * as assert from 'assert' +import * as fs from 'fs' +const RULE_CONFIG_PATH = 'rule_config.json' +const logger = require('../../src/util/logger')(__filename) +const { handleException } = require('../../src/engine/analyzer/common/exception-handler') +const fileUtil = require('../../src/util/file-util') + +async function regressionEggBenchmark(): Promise { + const benchmarkRootPath = path.resolve(__dirname, BENCHMARKS_DIR) + const benchmarkDir = fs.readdirSync(benchmarkRootPath) + for (const benchmarkPathItem of benchmarkDir) { + let filePath = path.join(benchmarkRootPath, benchmarkPathItem) + const fileStat = fs.lstatSync(filePath) + if (fileStat.isDirectory()) { + filePath = filePath + '/' + if (benchmarkPathItem !== XAST_JS_BENCHMARK) { + logger.info('execute test in ', filePath) + const result = await runEggBenchmark(filePath) + checkEggBenchmarkResult(result, filePath) + } + } + } +} + +async function runEggBenchmark(dir: string): Promise< + | { + expectedRes: any + actualRes: any + expectedResMap: Map + actualResMap: Map + accuracyStats: AccuracyStats | null + } + | undefined +> { + try { + const ruleConfigFile = path.join(path.resolve(dir), RULE_CONFIG_PATH) + const expectPath = getExpectResultPath(dir) + + const repoName = path.basename(dir) + const reportDir = path.join(__dirname, 'report', repoName) + let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map + let recorder = recordFindingStr() + recorder.clearResult() + + let args = [ + dir, + '--ruleConfigFile', + ruleConfigFile, + '--analyzer', + 'EggAnalyzer', + '--checkerPackIds', + 'taint-flow-javascript-inner', + '--report', + reportDir, + ] + + await execute(null, args, recorder.printAndAppend, false) + expectedRes = readExpectRes(expectPath) + actualRes = recorder.getFormatResult() + expectedResMap = resolveFindingResult(expectedRes) + actualResMap = resolveFindingResult(actualRes) + + // 计算 trace 准确率 + let accuracyStats: AccuracyStats | null = null + const sarifPath = path.join(reportDir, 'report.sarif') + if (fs.existsSync(sarifPath)) { + const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) + accuracyStats = computeAccuracyFromSarif(sarifData) + } + + return { + expectedRes, + actualRes, + expectedResMap, + actualResMap, + accuracyStats, + } + } catch (e) { + handleException(e, `ERROR in runEggBenchmark: ${e}`, `ERROR in runEggBenchmark: ${e}`) + process.exitCode = ErrorCode.unknown_error + } +} + +function checkEggBenchmarkResult( + result: + | { + expectedRes: any + actualRes: any + expectedResMap: Map + actualResMap: Map + accuracyStats: AccuracyStats | null + } + | undefined, + name: string +): void { + if (!result) return + + const description = `YASA test ${name.includes('chairbenchmark') ? 'chairBenchmark' : 'yasaNodeJsBenchmark'}` + describe(description, async function () { + this.timeout(10000) // 设置超时时间 + + it(`check result data directly`, async function () { + const { expectedRes, actualRes } = result + logger.info(actualRes) + assert.strictEqual(actualRes, expectedRes, '当前靶场扫描结果与历史预期不一致,请逐个核对链路') + }) + let i = 1 + const { expectedResMap, actualResMap } = result + expectedResMap.forEach((value, key) => { + it(`${i++}-entryPoint:${key}`, async function () { + logger.info('expected:\n' + value) + logger.info('actual:\n' + actualResMap.get(key)) + if (actualResMap.has(key)) { + assert.strictEqual(actualResMap.get(key), value, `链路${key}实际trace或内容与预期不一致，请核对该链路`) + } else { + assert.fail(`链路或key${key}不存在！！！`) + } + }) + }) + + const actualChains = Array.from(actualResMap.keys()) + let addChains = actualChains.filter((key) => !expectedResMap.has(key)) + if (Array.isArray(addChains) && addChains.length > 0) { + for (const addChain of addChains) { + it(`new chain:${addChain}`, function () { + logger.info(`新增检出${addChain},请核对新增检出内容是否符合预期`) + logger.info(actualResMap.get(addChain)) + assert.fail(`new chain:${addChain}`) + }) + } + } + + it(`trace accuracy`, function () { + const { accuracyStats } = result + if (!accuracyStats) { + this.skip() + return + } + const benchmarkName = name.includes('chairbenchmark') ? 'chairBenchmark' : 'yasaNodeJsBenchmark' + const pct = + accuracyStats.evaluableHops > 0 + ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) + : 'N/A' + logger.info( + `=== Trace Accuracy [${benchmarkName}]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` + ) + }) + }) +} + +async function updateBackup(dir: string): Promise { + const ruleConfigFile = path.join(path.resolve(dir), 'rule_config.json') + const repoName = path.basename(dir) + let actualRes: any + let recorder = recordFindingStr() + recorder.clearResult() + let args = [ + dir, + '--ruleConfigFile', + ruleConfigFile, + '--analyzer', + 'EggAnalyzer', + '--checkerPackIds', + 'taint-flow-javascript-inner', + ] + try { + await execute(null, args, recorder.printAndAppend, false) + } catch (e) { + handleException( + e, + `[test-egg-benchmark] 更新备份时发生错误，ERROR: ${e}`, + `[test-egg-benchmark] 更新备份时发生错误，ERROR: ${e}` + ) + recorder.clearResult() + process.exitCode = ErrorCode.unknown_error + } + actualRes = recorder.getFormatResult() + fs.writeFileSync(path.join(path.resolve(dir), '..', '..', 'expect', `${repoName}-expect.result`), actualRes, { + encoding: 'utf8', + }) +} + +regressionEggBenchmark() +// const benchmarkPath = fileUtil.getAbsolutePath('./test/javascript/benchmarks/yasaNodeJsBenchmark/') +// updateBackup(benchmarkPath) + +module.exports = { + regressionEggBenchmark, +} diff --git a/test/php/checker-cases/test_callchain.php b/test/php/checker-cases/test_callchain.php new file mode 100644 index 00000000..222a2dde --- /dev/null +++ b/test/php/checker-cases/test_callchain.php @@ -0,0 +1,14 @@ + diff --git a/test/php/checker-cases/test_cmdi.php b/test/php/checker-cases/test_cmdi.php new file mode 100644 index 00000000..078685cc --- /dev/null +++ b/test/php/checker-cases/test_cmdi.php @@ -0,0 +1,5 @@ + system +$cmd = $_REQUEST['cmd']; +system($cmd); +?> diff --git a/test/php/checker-cases/test_sqli.php b/test/php/checker-cases/test_sqli.php new file mode 100644 index 00000000..d2c2d8b0 --- /dev/null +++ b/test/php/checker-cases/test_sqli.php @@ -0,0 +1,6 @@ + mysqli_query +$id = $_GET['id']; +$query = "SELECT * FROM users WHERE id = " . $id; +mysqli_query($conn, $query); +?> diff --git a/test/php/checker-cases/test_xss.php b/test/php/checker-cases/test_xss.php new file mode 100644 index 00000000..885ef704 --- /dev/null +++ b/test/php/checker-cases/test_xss.php @@ -0,0 +1,5 @@ + echo +$name = $_POST['name']; +echo $name; +?> diff --git a/test/php/expect/phpbenchmark-expect.json b/test/php/expect/phpbenchmark-expect.json new file mode 100644 index 00000000..47743e60 --- /dev/null +++ b/test/php/expect/phpbenchmark-expect.json @@ -0,0 +1 @@ +{"/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\nLine 15: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\",\"functionName\":\"argument_return_value_passing_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\n AffectedNodeName: process\n 19: CALL: process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\n AffectedNodeName: arg\n 14: ARG PASS: function process($arg) {\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($arg);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\",\"functionName\":\"argument_return_value_passing_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: $result = getData($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\n AffectedNodeName: getData\n 19: CALL: $result = getData($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\n AffectedNodeName: getData\n 19: CALL RETURN: $result = getData($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\n AffectedNodeName: result\n 19: Var Pass: $result = getData($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_003_T.php\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\nLine 19: __taint_sink(arg)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\",\"functionName\":\"argument_return_value_passing_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: layer1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: layer1\n 23: CALL: layer1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: arg\n 14: ARG PASS: function layer1($arg) {\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: layer2\n 15: CALL: layer2($arg);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: arg\n 18: ARG PASS: function layer2($arg) {\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_005_T.php\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink($arg);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\nLine 24: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\",\"functionName\":\"argument_return_value_passing_007_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: $result = outer($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\n AffectedNodeName: outer\n 23: CALL: $result = outer($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\n AffectedNodeName: outer\n 23: CALL RETURN: $result = outer($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\n AffectedNodeName: result\n 23: Var Pass: $result = outer($__taint_src);\n /sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_007_T.php\n AffectedNodeName: __taint_sink\n 24: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/argument_return_value_passing/argument_return_value_passing_008_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\nLine 21: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\",\"functionName\":\"multi_invoke_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: $a = process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\n AffectedNodeName: process\n 19: CALL: $a = process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\n AffectedNodeName: process\n 19: CALL RETURN: $a = process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\n AffectedNodeName: a\n 19: Var Pass: $a = process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($a);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\nLine 25: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\",\"functionName\":\"multi_invoke_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: $a = step1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\n AffectedNodeName: step1\n 23: CALL: $a = step1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\n AffectedNodeName: step1\n 23: CALL RETURN: $a = step1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\n AffectedNodeName: a\n 23: Var Pass: $a = step1($__taint_src);\n /sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($a);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/multi_invoke/multi_invoke_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\nLine 33: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\",\"functionName\":\"polymorphism_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\n AffectedNodeName: __taint_src\n 32: SOURCE: $result = $handler->handle($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\n AffectedNodeName: handle\n 32: CALL: $result = $handler->handle($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\n AffectedNodeName: handle\n 32: CALL RETURN: $result = $handler->handle($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\n AffectedNodeName: result\n 32: Var Pass: $result = $handler->handle($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_001_T.php\n AffectedNodeName: __taint_sink\n 33: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\nLine 33: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\",\"functionName\":\"polymorphism_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\n AffectedNodeName: __taint_src\n 32: SOURCE: $result = $processor->process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\n AffectedNodeName: process\n 32: CALL: $result = $processor->process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\n AffectedNodeName: process\n 32: CALL RETURN: $result = $processor->process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\n AffectedNodeName: result\n 32: Var Pass: $result = $processor->process($__taint_src);\n /sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_003_T.php\n AffectedNodeName: __taint_sink\n 33: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/context_sensitive/polymorphism/polymorphism_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T.php\nLine 18: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T.php\",\"functionName\":\"loop_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T.php\n AffectedNodeName: res\n 17: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_001_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F.php\nLine 17: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F.php\",\"functionName\":\"loop_stmt_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F.php\n AffectedNodeName: res\n 18: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_002_F.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T.php\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T.php\",\"functionName\":\"loop_stmt_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T.php\n AffectedNodeName: res\n 18: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_003_T.php\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/loop_stmt/loop_stmt_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T.php\",\"functionName\":\"normal_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\nLine 18: __taint_sink(c)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\",\"functionName\":\"normal_stmt_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $a = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\n AffectedNodeName: a\n 15: Var Pass: $a = $__taint_src;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\n AffectedNodeName: b\n 16: Var Pass: $b = $a;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\n AffectedNodeName: c\n 17: Var Pass: $c = $b;\n /sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_003_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($c);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/flow_sensitive/normal_stmt/normal_stmt_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\nLine 26: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\",\"functionName\":\"class_field_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\n AffectedNodeName: __taint_src\n 25: SOURCE: $obj = new DataHolder001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\n AffectedNodeName: __construct\n 25: CALL: $obj = new DataHolder001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\n AffectedNodeName: obj\n 25: Var Pass: $obj = new DataHolder001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_001_T.php\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink($obj->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\nLine 29: __taint_sink(obj.getValue())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\",\"functionName\":\"class_field_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\n AffectedNodeName: __taint_src\n 28: SOURCE: $obj->setValue($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\n AffectedNodeName: setValue\n 28: CALL: $obj->setValue($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\n AffectedNodeName: getValue\n 29: CALL RETURN: __taint_sink($obj->getValue());\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_003_T.php\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink($obj->getValue());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\nLine 32: __taint_sink(obj.inner.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\",\"functionName\":\"class_field_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\n AffectedNodeName: __taint_src\n 31: SOURCE: $obj = new Outer005($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\n AffectedNodeName: __construct\n 31: CALL: $obj = new Outer005($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\n AffectedNodeName: obj\n 31: Var Pass: $obj = new Outer005($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/class_field/class_field_005_T.php\n AffectedNodeName: __taint_sink\n 32: SINK: __taint_sink($obj->inner->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/class_field/class_field_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\nLine 42: __taint_sink(a.b.c.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\",\"functionName\":\"field_len_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\n AffectedNodeName: __taint_src\n 41: SOURCE: $a = new A001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\n AffectedNodeName: __construct\n 41: CALL: $a = new A001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\n AffectedNodeName: a\n 41: Var Pass: $a = new A001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_001_T.php\n AffectedNodeName: __taint_sink\n 42: SINK: __taint_sink($a->b->c->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\nLine 48: __taint_sink(a.b.c.d.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\",\"functionName\":\"field_len_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\n AffectedNodeName: __taint_src\n 47: SOURCE: $a = new A003($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\n AffectedNodeName: __construct\n 47: CALL: $a = new A003($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\n AffectedNodeName: a\n 47: Var Pass: $a = new A003($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_003_T.php\n AffectedNodeName: __taint_sink\n 48: SINK: __taint_sink($a->b->c->d->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\nLine 34: __taint_sink(obj.inner.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\",\"functionName\":\"field_len_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\n AffectedNodeName: __taint_src\n 33: SOURCE: $obj = new Outer005FL($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\n AffectedNodeName: __construct\n 33: CALL: $obj = new Outer005FL($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\n AffectedNodeName: obj\n 33: Var Pass: $obj = new Outer005FL($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/field_len/field_len_005_T.php\n AffectedNodeName: __taint_sink\n 34: SINK: __taint_sink($obj->inner->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/field_len/field_len_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T.php\nLine 16: __taint_sink(arr.0.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T.php\",\"functionName\":\"multidimensional_collection_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $arr = [[$__taint_src, \"safe\"], [\"safe_a\", \"safe_b\"]];\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T.php\n AffectedNodeName: arr\n 15: Var Pass: $arr = [[$__taint_src, \"safe\"], [\"safe_a\", \"safe_b\"]];\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($arr[0][0]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T.php\nLine 21: __taint_sink(map.level1.tainted)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T.php\",\"functionName\":\"multidimensional_collection_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: \"tainted\" => $__taint_src,\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T.php\n AffectedNodeName: map\n 15: Var Pass: $map = [\n 16: Var Pass: \"level1\" => [\n 17: Var Pass: \"tainted\" => $__taint_src,\n 18: Var Pass: \"safe\" => \"safe_value\"\n 19: Var Pass: ]\n 20: Var Pass: ];\n /sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_003_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($map[\"level1\"][\"tainted\"]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/multidimensional_collection/multidimensional_collection_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\nLine 25: __taint_sink(tainted.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\",\"functionName\":\"object_sensitive_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: $tainted = new Item001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\n AffectedNodeName: __construct\n 23: CALL: $tainted = new Item001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\n AffectedNodeName: tainted\n 23: Var Pass: $tainted = new Item001($__taint_src);\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_001_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($tainted->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\nLine 24: __taint_sink(arr.0.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\",\"functionName\":\"object_sensitive_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: $arr = [new Item003($__taint_src), new Item003(\"safe_value\")];\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\n AffectedNodeName: __construct\n 23: CALL: $arr = [new Item003($__taint_src), new Item003(\"safe_value\")];\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\n AffectedNodeName: arr\n 23: Var Pass: $arr = [new Item003($__taint_src), new Item003(\"safe_value\")];\n /sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_003_T.php\n AffectedNodeName: __taint_sink\n 24: SINK: __taint_sink($arr[0]->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/object_sensitive/object_sensitive_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T.php\nLine 16: __taint_sink(arr.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T.php\",\"functionName\":\"one_collection_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $arr = [$__taint_src, \"safe_b\", \"safe_c\"];\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T.php\n AffectedNodeName: arr\n 15: Var Pass: $arr = [$__taint_src, \"safe_b\", \"safe_c\"];\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($arr[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T.php\nLine 16: __taint_sink(map.tainted)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T.php\",\"functionName\":\"one_collection_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $map = [\"tainted\" => $__taint_src, \"safe\" => \"safe_value\"];\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T.php\n AffectedNodeName: map\n 15: Var Pass: $map = [\"tainted\" => $__taint_src, \"safe\" => \"safe_value\"];\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_003_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($map[\"tainted\"]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T.php\nLine 18: __taint_sink(arr.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T.php\",\"functionName\":\"one_collection_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $arr[] = $__taint_src;\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T.php\n AffectedNodeName: arr[Noop]\n 16: Var Pass: $arr[] = $__taint_src;\n /sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_005_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($arr[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/object_field_sensitive/one_collection/one_collection_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_001_T.php\nLine 16: __taint_sink(__taint_src)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_001_T.php\",\"functionName\":\"exception_throw_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_001_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: __taint_sink($__taint_src);\n /sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($__taint_src);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T.php\nLine 18: __taint_sink(e.getMessage())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T.php\",\"functionName\":\"exception_throw_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: throw new Exception($__taint_src);\n /sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T.php\n AffectedNodeName: new Exception(__taint_src)\n 16: Throw Pass: throw new Exception($__taint_src);\n /sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_003_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($e->getMessage());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/exception_throw/exception_throw_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T.php\nLine 20: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T.php\",\"functionName\":\"explicit_jump_control_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T.php\n AffectedNodeName: res\n 17: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_001_T.php\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\",\"functionName\":\"explicit_jump_control_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\n AffectedNodeName: __taint_src\n 20: SOURCE: $res = getResult($__taint_src);\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\n AffectedNodeName: getResult\n 20: CALL: $res = getResult($__taint_src);\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\n AffectedNodeName: getResult\n 20: CALL RETURN: $res = getResult($__taint_src);\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\n AffectedNodeName: res\n 20: Var Pass: $res = getResult($__taint_src);\n /sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_003_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/explicit_jump_control/explicit_jump_control_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T.php\nLine 19: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T.php\",\"functionName\":\"loop_conditional_stmt_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T.php\n AffectedNodeName: res\n 17: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_001_T.php\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T.php\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T.php\",\"functionName\":\"loop_conditional_stmt_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T.php\n AffectedNodeName: res\n 18: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_003_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F.php\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F.php\",\"functionName\":\"loop_conditional_stmt_004_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F.php\n AffectedNodeName: res\n 18: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_004_F.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T.php\nLine 21: __taint_sink(res)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T.php\",\"functionName\":\"loop_conditional_stmt_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T.php\n AffectedNodeName: res\n 19: Var Pass: $res = $__taint_src;\n /sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_005_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($res);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/accuracy/path_sensitive/loop_conditional_stmt/loop_conditional_stmt_006_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/compact_extract/compact_extract_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/compact_extract/compact_extract_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/compact_extract/compact_extract_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/compact_extract/compact_extract_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/eval/eval_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/eval/eval_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/eval/eval_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/eval/eval_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/variable_variables/variable_variables_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/variable_variables/variable_variables_001_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/variable_variables/variable_variables_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/dynamic_tracing/variable_variables/variable_variables_002_T":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/alias_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/alias_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\nLine 13: __taint_sink(b)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\",\"functionName\":\"alias_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\n AffectedNodeName: a\n 11: Var Pass: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\n AffectedNodeName: b\n 12: Var Pass: $b = $a;\n /sast-php/case/completeness/single_app_tracing/alias/alias_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($b);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\nLine 13: __taint_sink(b)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\",\"functionName\":\"reference_assign_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\n AffectedNodeName: a\n 11: Var Pass: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\n AffectedNodeName: b\n 12: Var Pass: $b = &$a;\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($b);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T.php\nLine 14: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T.php\",\"functionName\":\"reference_assign_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $b = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T.php\n AffectedNodeName: b\n 13: Var Pass: $b = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/alias/reference_assign_002_T.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($a);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/abstract_class_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\nLine 23: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\",\"functionName\":\"abstract_class_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\n AffectedNodeName: __taint_src\n 22: SOURCE: $result = $handler->handle($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\n AffectedNodeName: handle\n 22: CALL: $result = $handler->handle($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\n AffectedNodeName: handle\n 22: CALL RETURN: $result = $handler->handle($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\n AffectedNodeName: result\n 22: Var Pass: $result = $handler->handle($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/abstract_class_001_T.php\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\",\"functionName\":\"anonymous_class_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $result = $obj->run($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\n AffectedNodeName: [return value]\n 13: Return Value: return $data;\n /sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\n AffectedNodeName: run\n 16: CALL RETURN: $result = $obj->run($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\n AffectedNodeName: result\n 16: Var Pass: $result = $obj->run($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/anonymous_class_001_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/enum_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/enum_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/enum_001_T.php\nLine 22: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/enum_001_T.php\",\"functionName\":\"enum_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/enum_001_T.php\n AffectedNodeName: __taint_src\n 21: SOURCE: $result = $status->format($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/enum_001_T.php\n AffectedNodeName: result\n 21: Var Pass: $result = $status->format($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/enum_001_T.php\n AffectedNodeName: __taint_sink\n 22: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/interface_impl_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\nLine 23: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\",\"functionName\":\"interface_impl_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\n AffectedNodeName: __taint_src\n 22: SOURCE: $result = $processor->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\n AffectedNodeName: process\n 22: CALL: $result = $processor->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\n AffectedNodeName: process\n 22: CALL RETURN: $result = $processor->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\n AffectedNodeName: result\n 22: Var Pass: $result = $processor->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_001_T.php\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/interface_impl_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\nLine 27: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\",\"functionName\":\"interface_impl_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\n AffectedNodeName: __taint_src\n 26: SOURCE: $result = processWithInterface($t, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\n AffectedNodeName: processWithInterface\n 26: CALL: $result = processWithInterface($t, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\n AffectedNodeName: processWithInterface\n 26: CALL RETURN: $result = processWithInterface($t, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\n AffectedNodeName: result\n 26: Var Pass: $result = processWithInterface($t, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/interface_impl_002_T.php\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\nLine 28: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\",\"functionName\":\"late_static_binding_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\n AffectedNodeName: __taint_src\n 27: SOURCE: $result = TaintedProvider::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\n AffectedNodeName: process\n 27: CALL: $result = TaintedProvider::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\n AffectedNodeName: process\n 27: CALL RETURN: $result = TaintedProvider::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\n AffectedNodeName: result\n 27: Var Pass: $result = TaintedProvider::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/late_static_binding_001_T.php\n AffectedNodeName: __taint_sink\n 28: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\nLine 25: __taint_sink(obj.tainted)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\",\"functionName\":\"magic_method_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\n AffectedNodeName: __taint_src\n 24: SOURCE: $obj->tainted = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\n AffectedNodeName: __set\n 24: CALL: $obj->tainted = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\n AffectedNodeName: __get\n 25: CALL RETURN: __taint_sink($obj->tainted);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_001_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($obj->tainted);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\nLine 25: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\",\"functionName\":\"magic_method_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: $obj = new TaintString($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: __construct\n 23: CALL: $obj = new TaintString($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: obj\n 23: Var Pass: $obj = new TaintString($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: __toString\n 24: CALL RETURN: $result = (string)$obj;\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: result\n 24: Var Pass: $result = (string)$obj;\n /sast-php/case/completeness/single_app_tracing/class/magic_method_002_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/magic_method_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\",\"functionName\":\"magic_method_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $result = $obj($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\n AffectedNodeName: __invoke\n 18: CALL: $result = $obj($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\n AffectedNodeName: __invoke\n 18: CALL RETURN: $result = $obj($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\n AffectedNodeName: result\n 18: Var Pass: $result = $obj($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/magic_method_003_T.php\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/readonly_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/readonly_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\nLine 18: __taint_sink(config.value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\",\"functionName\":\"readonly_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $config = new Config($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\n AffectedNodeName: __construct\n 17: CALL: $config = new Config($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\n AffectedNodeName: config\n 17: Var Pass: $config = new Config($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/readonly_001_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($config->value);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/simple_object_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/simple_object_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\nLine 25: __taint_sink(obj.getValue())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\",\"functionName\":\"simple_object_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\n AffectedNodeName: __taint_src\n 24: SOURCE: $obj->setValue($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\n AffectedNodeName: setValue\n 24: CALL: $obj->setValue($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\n AffectedNodeName: getValue\n 25: CALL RETURN: __taint_sink($obj->getValue());\n /sast-php/case/completeness/single_app_tracing/class/simple_object_001_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($obj->getValue());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/simple_object_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/simple_object_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/simple_object_002_T.php\nLine 17: __taint_sink(obj.data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/simple_object_002_T.php\",\"functionName\":\"simple_object_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/simple_object_002_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $obj->data = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/class/simple_object_002_T.php\n AffectedNodeName: obj.data\n 16: Var Pass: $obj->data = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/class/simple_object_002_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($obj->data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/subclass_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/subclass_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\nLine 27: __taint_sink(obj.getData())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\",\"functionName\":\"subclass_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\n AffectedNodeName: __taint_src\n 26: SOURCE: $obj->setData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\n AffectedNodeName: setData\n 26: CALL: $obj->setData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\n AffectedNodeName: getData\n 27: CALL RETURN: __taint_sink($obj->getData());\n /sast-php/case/completeness/single_app_tracing/class/subclass_001_T.php\n AffectedNodeName: __taint_sink\n 27: SINK: __taint_sink($obj->getData());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/subclass_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/subclass_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\nLine 25: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\",\"functionName\":\"subclass_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\n AffectedNodeName: __taint_src\n 24: SOURCE: $result = $obj->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\n AffectedNodeName: process\n 24: CALL: $result = $obj->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\n AffectedNodeName: process\n 24: CALL RETURN: $result = $obj->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\n AffectedNodeName: result\n 24: Var Pass: $result = $obj->process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/subclass_002_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/trait_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/trait_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\nLine 23: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\",\"functionName\":\"trait_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\n AffectedNodeName: __taint_src\n 22: SOURCE: $result = $obj->passData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\n AffectedNodeName: passData\n 22: CALL: $result = $obj->passData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\n AffectedNodeName: passData\n 22: CALL RETURN: $result = $obj->passData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\n AffectedNodeName: result\n 22: Var Pass: $result = $obj->passData($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_001_T.php\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/trait_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/class/trait_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\nLine 29: __taint_sink(obj.retrieve())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\",\"functionName\":\"trait_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\n AffectedNodeName: __taint_src\n 28: SOURCE: $obj->store($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\n AffectedNodeName: store\n 28: CALL: $obj->store($__taint_src);\n /sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\n AffectedNodeName: retrieve\n 29: CALL RETURN: __taint_sink($obj->retrieve());\n /sast-php/case/completeness/single_app_tracing/class/trait_002_T.php\n AffectedNodeName: __taint_sink\n 29: SINK: __taint_sink($obj->retrieve());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T.php\",\"functionName\":\"conditional_if_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: if (strlen($__taint_src) > 0) {\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T.php\n AffectedNodeName: result\n 13: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F.php\",\"functionName\":\"conditional_if_002_F\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F.php\n AffectedNodeName: result\n 11: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_if_002_F.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T.php\",\"functionName\":\"conditional_match_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T.php\n AffectedNodeName: __taint_src\n 13: SOURCE: 1 => $__taint_src,\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T.php\n AffectedNodeName: result\n 12: Var Pass: $result = match($type) {\n 13: Var Pass: 1 => $__taint_src,\n 14: Var Pass: 2 => \"safe_value\",\n 15: Var Pass: default => \"default_safe\",\n 16: Var Pass: };\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_001_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_match_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T.php\nLine 21: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T.php\",\"functionName\":\"conditional_switch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_001_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/conditional_stmt/conditional_switch_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T.php\",\"functionName\":\"loop_for_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T.php\n AffectedNodeName: result\n 13: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_for_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\",\"functionName\":\"loop_foreach_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\n AffectedNodeName: arr\n 11: Var Pass: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\n AffectedNodeName: result\n 14: Var Pass: $result = $item;\n /sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_foreach_001_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/control_flow/loop_stmt/loop_while_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/autoload_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/autoload_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"autoload_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $obj = new AutoClass($__taint_src);\n /main.php\n AffectedNodeName: __construct\n 15: CALL: $obj = new AutoClass($__taint_src);\n /main.php\n AffectedNodeName: obj\n 15: Var Pass: $obj = new AutoClass($__taint_src);\n /main.php\n AffectedNodeName: getData\n 16: CALL RETURN: $result = $obj->getData();\n /main.php\n AffectedNodeName: result\n 16: Var Pass: $result = $obj->getData();\n /main.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/autoload_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/autoload_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"autoload_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $result = $processor->handle($__taint_src);\n /main.php\n AffectedNodeName: handle\n 16: CALL: $result = $processor->handle($__taint_src);\n /main.php\n AffectedNodeName: handle\n 16: CALL RETURN: $result = $processor->handle($__taint_src);\n /main.php\n AffectedNodeName: result\n 16: Var Pass: $result = $processor->handle($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_inheritance_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_inheritance_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_inheritance_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $result = $handler->handle($__taint_src);\n /main.php\n AffectedNodeName: handle\n 17: CALL: $result = $handler->handle($__taint_src);\n /main.php\n AffectedNodeName: handle\n 17: CALL RETURN: $result = $handler->handle($__taint_src);\n /main.php\n AffectedNodeName: result\n 17: Var Pass: $result = $handler->handle($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_inheritance_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_inheritance_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 21: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_inheritance_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 20: SOURCE: $result = $processor->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 20: CALL: $result = $processor->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 20: CALL RETURN: $result = $processor->process($__taint_src);\n /main.php\n AffectedNodeName: result\n 20: Var Pass: $result = $processor->process($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_interface_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_interface_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 21: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_interface_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 20: SOURCE: $result = $obj->transform($__taint_src);\n /main.php\n AffectedNodeName: transform\n 20: CALL: $result = $obj->transform($__taint_src);\n /main.php\n AffectedNodeName: transform\n 20: CALL RETURN: $result = $obj->transform($__taint_src);\n /main.php\n AffectedNodeName: result\n 20: Var Pass: $result = $obj->transform($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_interface_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_interface_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 21: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_interface_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 20: SOURCE: $result = $worker->execute($__taint_src);\n /main.php\n AffectedNodeName: execute\n 20: CALL: $result = $worker->execute($__taint_src);\n /main.php\n AffectedNodeName: execute\n 20: CALL RETURN: $result = $worker->execute($__taint_src);\n /main.php\n AffectedNodeName: result\n 20: Var Pass: $result = $worker->execute($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_trait_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_trait_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 19: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_trait_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $result = $handler->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 18: CALL: $result = $handler->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 18: CALL RETURN: $result = $handler->process($__taint_src);\n /main.php\n AffectedNodeName: result\n 18: Var Pass: $result = $handler->process($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 19: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_trait_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/cross_file_trait_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 20: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"cross_file_trait_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 18: SOURCE: $svc->setData($__taint_src);\n /main.php\n AffectedNodeName: setData\n 18: CALL: $svc->setData($__taint_src);\n /main.php\n AffectedNodeName: getData\n 19: CALL RETURN: $result = $svc->getData();\n /main.php\n AffectedNodeName: result\n 19: Var Pass: $result = $svc->getData();\n /main.php\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/include_require_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/include_require_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"include_require_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: pass_through\n 13: CALL: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: pass_through\n 13: CALL RETURN: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: result\n 13: Var Pass: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/include_require_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/include_require_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"include_require_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 14: SOURCE: $result = $helper->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 14: CALL: $result = $helper->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 14: CALL RETURN: $result = $helper->process($__taint_src);\n /main.php\n AffectedNodeName: result\n 14: Var Pass: $result = $helper->process($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/namespace_use_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/namespace_use_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"namespace_use_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $result = $obj->getData($__taint_src);\n /main.php\n AffectedNodeName: getData\n 16: CALL: $result = $obj->getData($__taint_src);\n /main.php\n AffectedNodeName: getData\n 16: CALL RETURN: $result = $obj->getData($__taint_src);\n /main.php\n AffectedNodeName: result\n 16: Var Pass: $result = $obj->getData($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/namespace_use_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/namespace_use_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"namespace_use_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = Proc::handle($__taint_src);\n /main.php\n AffectedNodeName: result\n 15: Var Pass: $result = Proc::handle($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/require_once_001_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/require_once_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"require_once_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: pass_through\n 13: CALL: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: pass_through\n 13: CALL RETURN: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: result\n 13: Var Pass: $result = pass_through($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/require_once_002_F":"","/benchmarks/sast-php/case/completeness/single_app_tracing/cross_file_package_namespace/require_once_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/main.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/main.php\",\"functionName\":\"require_once_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /main.php\n AffectedNodeName: __taint_src\n 14: SOURCE: $result = $obj->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 14: CALL: $result = $obj->process($__taint_src);\n /main.php\n AffectedNodeName: process\n 14: CALL RETURN: $result = $obj->process($__taint_src);\n /main.php\n AffectedNodeName: result\n 14: Var Pass: $result = $obj->process($__taint_src);\n /main.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T.php\nLine 13: __taint_sink(arr.key)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T.php\",\"functionName\":\"array_element_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: $arr['key'] = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T.php\n AffectedNodeName: arr[key]\n 12: Var Pass: $arr['key'] = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/datatype/array_element_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($arr['key']);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/array_overwrite_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T.php\nLine 14: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T.php\",\"functionName\":\"array_push_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: array_push($arr, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T.php\n AffectedNodeName: result\n 13: Var Pass: $result = array_pop($arr);\n /sast-php/case/completeness/single_app_tracing/datatype/array_push_002_T.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/array_safe_key_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/int_arithmetic_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T.php\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T.php\",\"functionName\":\"int_to_string_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: $result = $__taint_src . strval($num);\n /sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T.php\n AffectedNodeName: result\n 12: Var Pass: $result = $__taint_src . strval($num);\n /sast-php/case/completeness/single_app_tracing/datatype/int_to_string_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T.php\",\"functionName\":\"string_concat_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = \"prefix_\" . $__taint_src;\n /sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = \"prefix_\" . $__taint_src;\n /sast-php/case/completeness/single_app_tracing/datatype/string_concat_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/string_constant_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/string_replace_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T.php\",\"functionName\":\"string_substr_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = substr($__taint_src, 0, 10);\n /sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = substr($__taint_src, 0, 10);\n /sast-php/case/completeness/single_app_tracing/datatype/string_substr_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T.php\nLine 12: __taint_sink(input)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T.php\",\"functionName\":\"superglobal_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T.php\n AffectedNodeName: _POST\n 11: SOURCE: $input = $_POST['input'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T.php\n AffectedNodeName: input\n 11: Var Pass: $input = $_POST['input'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($input);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T.php\nLine 12: __taint_sink(cookie)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T.php\",\"functionName\":\"superglobal_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T.php\n AffectedNodeName: _COOKIE\n 11: SOURCE: $cookie = $_COOKIE['key'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T.php\n AffectedNodeName: cookie\n 11: Var Pass: $cookie = $_COOKIE['key'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($cookie);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T.php\nLine 12: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T.php\",\"functionName\":\"superglobal_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T.php\n AffectedNodeName: _REQUEST\n 11: SOURCE: $data = $_REQUEST['data'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T.php\n AffectedNodeName: data\n 11: Var Pass: $data = $_REQUEST['data'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_003_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T.php\nLine 12: __taint_sink(ua)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T.php\",\"functionName\":\"superglobal_004_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T.php\n AffectedNodeName: _SERVER\n 11: SOURCE: $ua = $_SERVER['HTTP_USER_AGENT'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T.php\n AffectedNodeName: ua\n 11: Var Pass: $ua = $_SERVER['HTTP_USER_AGENT'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_004_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($ua);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T.php\nLine 12: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T.php\",\"functionName\":\"superglobal_005_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T.php\n AffectedNodeName: _SESSION\n 11: SOURCE: $data = $_SESSION['key'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T.php\n AffectedNodeName: data\n 11: Var Pass: $data = $_SESSION['key'];\n /sast-php/case/completeness/single_app_tracing/datatype/superglobal_005_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T.php\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T.php\",\"functionName\":\"try_catch_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T.php\n AffectedNodeName: result\n 13: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_001_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T.php\nLine 14: __taint_sink(e.getMessage())\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T.php\",\"functionName\":\"try_catch_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: throw new Exception($__taint_src);\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T.php\n AffectedNodeName: new Exception(__taint_src)\n 12: Throw Pass: throw new Exception($__taint_src);\n /sast-php/case/completeness/single_app_tracing/exception_error/try_catch_002_T.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($e->getMessage());\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/exception_error/try_finally_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\nLine 13: __taint_sink(b)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\",\"functionName\":\"basic_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\n AffectedNodeName: a\n 11: Var Pass: $a = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\n AffectedNodeName: b\n 12: Var Pass: $b = $a;\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($b);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_T.php\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_T.php\",\"functionName\":\"basic_expression_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: $result .= $__taint_src;\n /sast-php/case/completeness/single_app_tracing/expression/basic_expression_002_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T.php\",\"functionName\":\"conditional_expression_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = true ? $__taint_src : \"safe\";\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = true ? $__taint_src : \"safe\";\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T.php\",\"functionName\":\"conditional_expression_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = $__taint_src ?? \"default_safe\";\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = $__taint_src ?? \"default_safe\";\n /sast-php/case/completeness/single_app_tracing/expression/conditional_expression_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/destructuring_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T.php\nLine 13: __taint_sink(a)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T.php\",\"functionName\":\"destructuring_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T.php\n AffectedNodeName: arr\n 11: Var Pass: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_001_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($a);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/destructuring_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T.php\nLine 13: __taint_sink(b)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T.php\",\"functionName\":\"destructuring_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $arr = [\"safe\", $__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T.php\n AffectedNodeName: arr\n 11: Var Pass: $arr = [\"safe\", $__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/destructuring_002_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($b);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/heredoc_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/heredoc_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/heredoc_001_T.php\nLine 14: __taint_sink(str)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/heredoc_001_T.php\",\"functionName\":\"heredoc_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/heredoc_001_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: command: $__taint_src\n /sast-php/case/completeness/single_app_tracing/expression/heredoc_001_T.php\n AffectedNodeName: str\n 11: Var Pass: $str = <<getData();\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_001_T.php\n AffectedNodeName: result\n 22: Var Pass: $result = $obj?->getData();\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_001_T.php\n AffectedNodeName: __taint_sink\n 23: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\nLine 34: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\",\"functionName\":\"nullsafe_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: __taint_src\n 31: SOURCE: $inner = new Inner($__taint_src);\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: __construct\n 31: CALL: $inner = new Inner($__taint_src);\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: inner\n 31: Var Pass: $inner = new Inner($__taint_src);\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: __construct\n 32: CALL: $obj = new Outer($inner);\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: obj\n 32: Var Pass: $obj = new Outer($inner);\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: getInner\n 33: CALL RETURN: $result = $obj?->getInner()?->getValue();\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: getValue\n 33: CALL RETURN: $result = $obj?->getInner()?->getValue();\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: result\n 33: Var Pass: $result = $obj?->getInner()?->getValue();\n /sast-php/case/completeness/single_app_tracing/expression/nullsafe_002_T.php\n AffectedNodeName: __taint_sink\n 34: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/spread_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/spread_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\nLine 11: __taint_sink(cmd)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\",\"functionName\":\"spread_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $args = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\n AffectedNodeName: args\n 15: Var Pass: $args = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\n AffectedNodeName: execute\n 16: CALL: execute(...$args);\n /sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\n AffectedNodeName: cmd\n 10: ARG PASS: function execute($cmd) {\n /sast-php/case/completeness/single_app_tracing/expression/spread_001_T.php\n AffectedNodeName: __taint_sink\n 11: SINK: __taint_sink($cmd);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/spread_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/spread_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\nLine 14: __taint_sink(merged.1)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\",\"functionName\":\"spread_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: $arr2 = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\n AffectedNodeName: arr2\n 12: Var Pass: $arr2 = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\n AffectedNodeName: merged\n 13: Var Pass: $merged = [...$arr1, ...$arr2];\n /sast-php/case/completeness/single_app_tracing/expression/spread_002_T.php\n AffectedNodeName: __taint_sink\n 14: SINK: __taint_sink($merged[1]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_func_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_func_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/string_func_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/string_func_001_T.php\",\"functionName\":\"string_func_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/string_func_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = sprintf('%s', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/expression/string_func_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = sprintf('%s', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/expression/string_func_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_func_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_func_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/string_func_002_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/string_func_002_T.php\",\"functionName\":\"string_func_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/string_func_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = implode(',', [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/expression/string_func_002_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = implode(',', [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/expression/string_func_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T.php\",\"functionName\":\"string_interpolation_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = \"cmd: $__taint_src\";\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = \"cmd: $__taint_src\";\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T.php\",\"functionName\":\"string_interpolation_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = \"execute: {$__taint_src}\";\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = \"execute: {$__taint_src}\";\n /sast-php/case/completeness/single_app_tracing/expression/string_interpolation_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/type_cast_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T.php\",\"functionName\":\"type_cast_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = (string)$__taint_src;\n /sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = (string)$__taint_src;\n /sast-php/case/completeness/single_app_tracing/expression/type_cast_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\nLine 15: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\",\"functionName\":\"anonymous_function_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\n AffectedNodeName: __taint_src\n 14: SOURCE: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\n AffectedNodeName: [return value]\n 12: Return Value: return $data;\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\n AffectedNodeName: \n 14: CALL RETURN: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\n AffectedNodeName: result\n 14: Var Pass: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\",\"functionName\":\"anonymous_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\n AffectedNodeName: [return value]\n 11: Return Value: $fn = fn($data) => $data;\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\n AffectedNodeName: \n 12: CALL RETURN: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\n AffectedNodeName: result\n 12: Var Pass: $result = $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/anonymous_function_002_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\nLine 15: __taint_sink(data)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\",\"functionName\":\"argument_passing_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: passToSink($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\n AffectedNodeName: passToSink\n 11: CALL: passToSink($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\n AffectedNodeName: data\n 14: ARG PASS: function passToSink($data) {\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($data);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T.php\nLine 13: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T.php\",\"functionName\":\"argument_passing_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T.php\n AffectedNodeName: __taint_src\n 12: SOURCE: setTaint($result, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T.php\n AffectedNodeName: setTaint\n 12: CALL: setTaint($result, $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_002_T.php\n AffectedNodeName: __taint_sink\n 13: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\",\"functionName\":\"argument_passing_003_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = level1($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\n AffectedNodeName: level1\n 11: CALL: $result = level1($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\n AffectedNodeName: level1\n 11: CALL RETURN: $result = level1($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = level1($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/argument_passing_003_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\nLine 26: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\",\"functionName\":\"chained_call_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: __taint_src\n 25: SOURCE: $result = $builder->setData($__taint_src)->build();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: setData\n 25: CALL: $result = $builder->setData($__taint_src)->build();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: setData\n 25: CALL RETURN: $result = $builder->setData($__taint_src)->build();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: build\n 25: CALL RETURN: $result = $builder->setData($__taint_src)->build();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: result\n 25: Var Pass: $result = $builder->setData($__taint_src)->build();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_001_T.php\n AffectedNodeName: __taint_sink\n 26: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\nLine 30: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\",\"functionName\":\"chained_call_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: __taint_src\n 29: SOURCE: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: input\n 29: CALL: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: input\n 29: CALL RETURN: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: process\n 29: CALL RETURN: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: output\n 29: CALL RETURN: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: result\n 29: Var Pass: $result = $pipe->input($__taint_src)->process()->output();\n /sast-php/case/completeness/single_app_tracing/function_call/chained_call_002_T.php\n AffectedNodeName: __taint_sink\n 30: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\nLine 11: __taint_sink(cmd)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\",\"functionName\":\"first_class_callable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\n AffectedNodeName: run_command\n 16: CALL: $fn($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\n AffectedNodeName: cmd\n 10: ARG PASS: function run_command($cmd) {\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_001_T.php\n AffectedNodeName: __taint_sink\n 11: SINK: __taint_sink($cmd);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\nLine 17: __taint_sink(results.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\",\"functionName\":\"first_class_callable_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $results = array_map($fn, [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\n AffectedNodeName: wrap\n 16: CALL: $results = array_map($fn, [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\n AffectedNodeName: wrap\n 16: CALL RETURN: $results = array_map($fn, [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\n AffectedNodeName: results\n 16: Var Pass: $results = array_map($fn, [$__taint_src]);\n /sast-php/case/completeness/single_app_tracing/function_call/first_class_callable_002_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($results[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/generator_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/generator_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\nLine 16: __taint_sink(value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\",\"functionName\":\"generator_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: foreach (taintedGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\n AffectedNodeName: taintedGenerator\n 15: CALL: foreach (taintedGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\n AffectedNodeName: taintedGenerator\n 15: CALL RETURN: foreach (taintedGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($value);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/generator_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/generator_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\nLine 20: __taint_sink(value)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\",\"functionName\":\"generator_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: foreach (outerGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\n AffectedNodeName: outerGenerator\n 19: CALL: foreach (outerGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\n AffectedNodeName: outerGenerator\n 19: CALL RETURN: foreach (outerGenerator($__taint_src) as $value) {\n /sast-php/case/completeness/single_app_tracing/function_call/generator_002_T.php\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink($value);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\nLine 15: __taint_sink(mapped.0)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\",\"functionName\":\"higher_order_function_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $arr = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: arr\n 11: Var Pass: $arr = [$__taint_src];\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: [return value]\n 13: Return Value: return $item;\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: \n 12: CALL RETURN: $mapped = array_map(function($item) {\n 13: CALL RETURN: return $item;\n 14: CALL RETURN: }, $arr);\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: mapped\n 12: Var Pass: $mapped = array_map(function($item) {\n 13: Var Pass: return $item;\n 14: Var Pass: }, $arr);\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_001_T.php\n AffectedNodeName: __taint_sink\n 15: SINK: __taint_sink($mapped[0]);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\",\"functionName\":\"higher_order_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\n AffectedNodeName: arr\n 11: Var Pass: $arr = [$__taint_src, \"safe\"];\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\n AffectedNodeName: filtered\n 12: Var Pass: $filtered = array_filter($arr, function($item) {\n 13: Var Pass: return strlen($item) > 0;\n 14: Var Pass: });\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = reset($filtered);\n /sast-php/case/completeness/single_app_tracing/function_call/higher_order_function_002_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\",\"functionName\":\"named_arg_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = process(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\n AffectedNodeName: process\n 15: CALL: $result = process(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\n AffectedNodeName: process\n 15: CALL RETURN: $result = process(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = process(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\",\"functionName\":\"named_arg_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = execute(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\n AffectedNodeName: execute\n 15: CALL: $result = execute(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\n AffectedNodeName: execute\n 15: CALL RETURN: $result = execute(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = execute(cmd: $__taint_src, mode: \"default\");\n /sast-php/case/completeness/single_app_tracing/function_call/named_arg_002_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/return_value_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\",\"functionName\":\"return_value_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = getInput($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\n AffectedNodeName: getInput\n 11: CALL: $result = getInput($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\n AffectedNodeName: getInput\n 11: CALL RETURN: $result = getInput($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = getInput($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_001_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/return_value_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\nLine 12: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\",\"functionName\":\"return_value_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: wrapB\n 11: CALL: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: wrapB\n 11: CALL RETURN: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: wrapA\n 11: CALL: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: wrapA\n 11: CALL RETURN: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: result\n 11: Var Pass: $result = wrapA(wrapB($__taint_src));\n /sast-php/case/completeness/single_app_tracing/function_call/return_value_002_T.php\n AffectedNodeName: __taint_sink\n 12: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/static_method_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\nLine 18: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\",\"functionName\":\"static_method_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\n AffectedNodeName: __taint_src\n 17: SOURCE: $result = Processor::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\n AffectedNodeName: process\n 17: CALL: $result = Processor::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\n AffectedNodeName: process\n 17: CALL RETURN: $result = Processor::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\n AffectedNodeName: result\n 17: Var Pass: $result = Processor::process($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_001_T.php\n AffectedNodeName: __taint_sink\n 18: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/static_method_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\nLine 25: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\",\"functionName\":\"static_method_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\n AffectedNodeName: __taint_src\n 23: SOURCE: Registry::set($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\n AffectedNodeName: set\n 23: CALL: Registry::set($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\n AffectedNodeName: get\n 24: CALL RETURN: $result = Registry::get();\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\n AffectedNodeName: result\n 24: Var Pass: $result = Registry::get();\n /sast-php/case/completeness/single_app_tracing/function_call/static_method_002_T.php\n AffectedNodeName: __taint_sink\n 25: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\nLine 17: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\",\"functionName\":\"variable_function_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\n AffectedNodeName: __taint_src\n 16: SOURCE: $result = $func($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\n AffectedNodeName: passThrough\n 16: CALL: $result = $func($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\n AffectedNodeName: passThrough\n 16: CALL RETURN: $result = $func($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\n AffectedNodeName: result\n 16: Var Pass: $result = $func($__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_001_T.php\n AffectedNodeName: __taint_sink\n 17: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\",\"functionName\":\"variable_function_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: $result = call_user_func('identity', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\n AffectedNodeName: identity\n 15: CALL: $result = call_user_func('identity', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\n AffectedNodeName: identity\n 15: CALL RETURN: $result = call_user_func('identity', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = call_user_func('identity', $__taint_src);\n /sast-php/case/completeness/single_app_tracing/function_call/variable_function_002_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\",\"functionName\":\"closure_use_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: __taint_src\n 11: SOURCE: $tainted = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: tainted\n 11: Var Pass: $tainted = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: [return value]\n 13: Return Value: return $tainted;\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: \n 15: CALL RETURN: $result = $fn();\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: result\n 15: Var Pass: $result = $fn();\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_001_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T.php\nLine 16: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T.php\",\"functionName\":\"closure_use_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T.php\n AffectedNodeName: __taint_src\n 13: SOURCE: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T.php\n AffectedNodeName: result\n 13: Var Pass: $result = $__taint_src;\n /sast-php/case/completeness/single_app_tracing/variable_scope/closure_use_002_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T.php\nLine 20: __taint_sink(globalTaint)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T.php\",\"functionName\":\"global_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: setGlobal($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T.php\n AffectedNodeName: setGlobal\n 19: CALL: setGlobal($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_001_T.php\n AffectedNodeName: __taint_sink\n 20: SINK: __taint_sink($globalTaint);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T.php\nLine 16: __taint_sink(GLOBALS.taintData)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T.php\",\"functionName\":\"global_variable_002_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T.php\n AffectedNodeName: __taint_src\n 15: SOURCE: setViaGlobals($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T.php\n AffectedNodeName: setViaGlobals\n 15: CALL: setViaGlobals($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/global_variable_002_T.php\n AffectedNodeName: __taint_sink\n 16: SINK: __taint_sink($GLOBALS['taintData']);\n==========================================================\n #Total-findings:1\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_F":"======================== Findings ========================\nNo findings!\n==========================================================","/benchmarks/sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T":"======================== Findings ========================\n\n------------- 1: taint_flow_test-------------\nDescription:taint_flow_test，回归测试使用，不推荐外部使用\nFile:/sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\nLine 21: __taint_sink(result)\nSINK RULE:__taint_sink\nentrypoint:\n{\"filePath\":\"/sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\",\"functionName\":\"static_variable_001_T\",\"attribute\":\"fullCallGraphMade\",\"type\":\"functionCall\",\"funcReceiverType\":\"\"}\nTrace:\n /sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\n AffectedNodeName: __taint_src\n 19: SOURCE: storeStatic($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\n AffectedNodeName: storeStatic\n 19: CALL: storeStatic($__taint_src);\n /sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\n AffectedNodeName: storeStatic\n 20: CALL RETURN: $result = storeStatic();\n /sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\n AffectedNodeName: result\n 20: Var Pass: $result = storeStatic();\n /sast-php/case/completeness/single_app_tracing/variable_scope/static_variable_001_T.php\n AffectedNodeName: __taint_sink\n 21: SINK: __taint_sink($result);\n==========================================================\n #Total-findings:1\n=========================================================="} \ No newline at end of file diff --git a/test/php/generate-expect.ts b/test/php/generate-expect.ts new file mode 100644 index 00000000..9eb1e40d --- /dev/null +++ b/test/php/generate-expect.ts @@ -0,0 +1,152 @@ +/** + * 独立生成 PHP benchmark expect 文件 + * 用法: npx tsx test/php/generate-expect.ts + */ +import * as fs from 'fs' +import * as path from 'path' +const config = require('../../src/config') +const PhpAnalyzer = require('../../src/engine/analyzer/php/common/php-analyzer') +const { recordFindingStr } = require('../test-utils') +const _ = require('lodash') +const { handleException } = require('../../src/engine/analyzer/common/exception-handler') +const OutputStrategyAutoRegister = require('../../src/engine/analyzer/common/output-strategy-auto-register') +const { execute } = require('../../src/interface/starter') +const logger = require('../../src/util/logger')(__filename) + +const taint_flow_name = ['taint_flow_test', 'taintflow'] + +interface TestUnit { + type: 'file' | 'dir' + path: string + label: string +} + +function getAllTestUnits(rootDir: string): TestUnit[] { + const units: TestUnit[] = [] + function scan(dir: string): void { + let entries: string[] + try { entries = fs.readdirSync(dir) } catch { return } + for (const entry of entries) { + const fullPath = path.join(dir, entry) + let stat: fs.Stats | undefined + try { stat = fs.lstatSync(fullPath) } catch { continue } + if (!stat) continue + if (stat.isDirectory()) { + if (/_[TF]$/.test(entry) && hasPhpFile(fullPath)) { + const label = fullPath.substring(fullPath.lastIndexOf('/benchmarks')) + units.push({ type: 'dir', path: fullPath, label }) + } else { + scan(fullPath) + } + } else if (stat.isFile() && /_(T|F)\.php$/.test(entry)) { + const label = fullPath.substring(fullPath.lastIndexOf('/benchmarks')).replace(/\.php$/, '') + units.push({ type: 'file', path: fullPath, label }) + } + } + } + scan(rootDir) + return units +} + +function hasPhpFile(dir: string): boolean { + try { + return fs.readdirSync(dir).some((e: string) => e.endsWith('.php')) + } catch { return false } +} + +async function runSingleTest(casePath: string, outputStrategyAutoRegister: any): Promise> { + config.ruleConfigFile = __dirname + '/rule_config.json' + config.checkerIds = ['taint_flow_test', 'sanitizer'] + config.language = 'php' + config.maindirPrefix = __dirname + '/benchmarks' + + const code = fs.readFileSync(casePath).toString() + const recorder = recordFindingStr() + const filename = casePath.substring(casePath.lastIndexOf('/benchmarks')).replace(/\.php$/g, '') + const analyzer = new PhpAnalyzer({ + language: 'php', + examineIssues: true, + checkers: { taint_flow_test: true, sanitizer: true }, + ...config, + mode: { intra: true }, + sanity: true, + }) + const findingRes = await analyzer.analyzeSingleFile(code, casePath) + if (findingRes) { + const { resultManager } = analyzer.getCheckerManager() + const allFindings = resultManager.getFindings() + if (_.isEmpty(allFindings)) { + recorder.printAndAppend('\n======================== Findings ======================== ') + recorder.printAndAppend('No findings!') + recorder.printAndAppend('========================================================== \n') + } + for (const outputStrategyId in allFindings) { + const strategy = outputStrategyAutoRegister.getStrategy(outputStrategyId) + if (strategy && typeof strategy.outputFindings === 'function') { + strategy.outputFindings(resultManager, strategy.getOutputFilePath(), config, recorder.printAndAppend) + } + } + } + return { [filename]: recorder.getFormatResult() } +} + +async function runDirectoryTest(dirPath: string, label: string): Promise> { + const ruleConfigFile = __dirname + '/rule_config.json' + const reportDir = path.join(__dirname, 'report') + const recorder = recordFindingStr() + const args: string[] = [ + dirPath, + '--ruleConfigFile', ruleConfigFile, + '--analyzer', 'PhpAnalyzer', + '--checkerIds', 'taint_flow_test,sanitizer', + '--report', reportDir, + ] + try { + await execute(null, args, recorder.printAndAppend) + } catch (e) { + handleException(e, `[generate-expect] 目录分析失败: ${label}`, `[generate-expect] 目录分析失败: ${label}`) + } + return { [label]: recorder.getFormatResult() } +} + +async function main(): Promise { + const benchmarkPath = path.resolve(__dirname, 'benchmarks/sast-php/') + const casePath = path.join(benchmarkPath, 'case') + + if (!fs.existsSync(casePath)) { + console.error(`靶场路径不存在: ${casePath}，请先运行 prepare-php-benchmark`) + process.exit(1) + } + + const allUnits = getAllTestUnits(casePath) + console.log(`扫描到 ${allUnits.length} 个测试单元`) + + const actualRes: Record = {} + const outputStrategyAutoRegister = new OutputStrategyAutoRegister() + outputStrategyAutoRegister.autoRegisterAllStrategies() + + for (let i = 0; i < allUnits.length; i++) { + const unit = allUnits[i] + try { + if (unit.type === 'file') { + Object.assign(actualRes, await runSingleTest(unit.path, outputStrategyAutoRegister)) + } else { + Object.assign(actualRes, await runDirectoryTest(unit.path, unit.label)) + } + if ((i + 1) % 50 === 0) console.log(` 进度: ${i + 1}/${allUnits.length}`) + } catch (e) { + console.error(`用例失败: ${unit.label}`) + } + } + + const expectDir = path.join(__dirname, 'expect') + if (!fs.existsSync(expectDir)) fs.mkdirSync(expectDir, { recursive: true }) + fs.writeFileSync( + path.join(expectDir, 'phpbenchmark-expect.json'), + JSON.stringify(actualRes), + { encoding: 'utf8' } + ) + console.log(`\n生成 expect 文件完成，共 ${Object.keys(actualRes).length} 个 case`) +} + +main() diff --git a/test/php/prepare-php-benchmark.ts b/test/php/prepare-php-benchmark.ts new file mode 100644 index 00000000..47b9515d --- /dev/null +++ b/test/php/prepare-php-benchmark.ts @@ -0,0 +1,132 @@ +import * as path from 'path' +import * as fs from 'fs-extra' +const simpleGit = require('simple-git') +const logger = require('../../src/util/logger')(__filename) +const { handleException } = require('../../src/engine/analyzer/common/exception-handler') +const git = simpleGit() +const BENCHMARKS_DIR = './benchmarks' + +interface BenchmarkRepo { + gitRepoUrl: string + branch: string +} + +interface BenchmarkRepoUrls { + [key: string]: BenchmarkRepo +} + +const BENCHMARK_REPO_URLS: BenchmarkRepoUrls = { + 'sast-php': { + gitRepoUrl: 'https://github.com/alipay/ant-application-security-testing-benchmark.git', + branch: 'jiufo/sast-php-benchmark', + }, +} + +async function cloneRepo(gitRepoUrl: string, targetDir: string, branch: string): Promise { + const absoluteTargetDir = path.resolve(targetDir) + let done = true + await git + .clone(gitRepoUrl, absoluteTargetDir, ['-b', branch]) + .then(() => logger.info(`仓库克隆成功！！！仓库:${gitRepoUrl} 已克隆至 ${targetDir}`)) + .catch((err: any) => { + done = false + handleException( + err, + `[prepare-php-benchmark] 克隆仓库:${gitRepoUrl}失败, 请手动克隆至 ${targetDir} 错误信息${err}`, + `[prepare-php-benchmark] 克隆仓库:${gitRepoUrl}失败, 请手动克隆至 ${targetDir} 错误信息${err}` + ) + }) + try { + cleanDirectoryForSastPhp(absoluteTargetDir) + moveSrcDirectoryForSastPhp(absoluteTargetDir) + } catch (e) { + handleException( + e, + `[prepare-php-benchmark] 清理目录时发生错误`, + `[prepare-php-benchmark] 清理目录时发生错误` + ) + done = false + } + return done +} + +async function prepareTest(): Promise { + const allRepoReady: boolean[] = [] + for (let key in BENCHMARK_REPO_URLS) { + const repoUrl = BENCHMARK_REPO_URLS[key].gitRepoUrl + const branch = BENCHMARK_REPO_URLS[key].branch + const targetDir = path.resolve(__dirname, BENCHMARKS_DIR, key) + if (fs.existsSync(targetDir)) { + fs.rmSync(targetDir, { recursive: true }) + } + fs.mkdirSync(targetDir, { recursive: true }) + let repoRes = await cloneRepo(repoUrl, targetDir, branch) + allRepoReady.push(repoRes) + } + return allRepoReady.length > 0 && allRepoReady.every((ready) => ready) +} + +/** + * 执行脚本需要做的准备工作是否ready + * @returns {boolean} + */ +function checkReady(): boolean { + try { + let rootDir = path.resolve(__dirname, BENCHMARKS_DIR) + const dirs = fs.readdirSync(rootDir) + let set = new Set(dirs) + set.delete('.DS_Store') + let ready = Object.keys(BENCHMARK_REPO_URLS).every((repo) => set.has(repo)) + return ready + } catch (e) { + handleException( + e, + `[prepare-php-benchmark] 靶场准备检查失败，靶场未准备`, + `[prepare-php-benchmark] 靶场准备检查失败，靶场未准备` + ) + return false + } +} + +async function doPrepare(): Promise { + let ready = checkReady() + logger.info(`检查xAST的sast-php靶场是否准备：${ready}`) + if (!ready) { + try { + logger.info(`开始克隆xAST的sast-php靶场...`) + await prepareTest() + } catch (e) { + handleException( + e, + `准备测试case失败，请手动准备xAST的sast-php靶场至测试目录${path.resolve(__dirname, BENCHMARKS_DIR)}`, + `准备测试case失败，请手动准备xAST的sast-php靶场至测试目录${path.resolve(__dirname, BENCHMARKS_DIR)}` + ) + return + } + logger.info(`仓库克隆成功`) + } + logger.info(`靶场已准备`) +} + +// 遍历并删除除 sast-php 以外的所有文件和文件夹 +function cleanDirectoryForSastPhp(directory: string): void { + fs.readdirSync(directory).forEach((item) => { + const itemPath = path.join(directory, item) + if (path.basename(itemPath) === 'sast-php' && fs.lstatSync(itemPath).isDirectory()) { + return + } + fs.removeSync(itemPath) + }) +} + +// 移动 sast-php/case 到上层目录 +function moveSrcDirectoryForSastPhp(directory: string): void { + const childPath = path.join(directory, 'sast-php') + const srcPath = path.join(childPath, 'case') + if (fs.existsSync(srcPath)) { + fs.moveSync(srcPath, path.join(directory, 'case')) + } + fs.removeSync(childPath) +} + +doPrepare() diff --git a/test/php/rule_config.json b/test/php/rule_config.json new file mode 100644 index 00000000..9dd1f062 --- /dev/null +++ b/test/php/rule_config.json @@ -0,0 +1,158 @@ +[ + { + "checkerIds": [ + "taint_flow_test" + ], + "sources": { + "TaintSource": [ + { + "path": "__taint_src" + }, + { + "path": "_POST" + }, + { + "path": "_GET" + }, + { + "path": "_REQUEST" + }, + { + "path": "_COOKIE" + }, + { + "path": "_SERVER" + }, + { + "path": "_SESSION" + } + ] + }, + "sanitizers": { + "FunctionCallSanitizer": [ + { + "fsig": "validateTaint", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R", + "P0" + ], + "isContinue": true + }, + { + "fsig": "htmlspecialchars", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "htmlentities", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "intval", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "escapeshellarg", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "escapeshellcmd", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "addslashes", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "strip_tags", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "str_replace", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + }, + { + "fsig": "strlen", + "args": [ + "*" + ], + "from": "P0", + "to": [ + "R" + ], + "isContinue": true + } + ] + }, + "sinks": { + "FuncCallTaintSink": [ + { + "fsig": "__taint_sink", + "args": [ + 0 + ], + "sanitizerIds": ["htmlspecialchars", "htmlentities", "intval", "escapeshellarg", "escapeshellcmd", "addslashes", "strip_tags", "str_replace", "strlen"] + } + ] + } + } +] diff --git a/test/php/test-php-benchmark.ts b/test/php/test-php-benchmark.ts new file mode 100644 index 00000000..9753f0af --- /dev/null +++ b/test/php/test-php-benchmark.ts @@ -0,0 +1,379 @@ +import * as fs from 'fs' +import * as path from 'path' +import { describe, it, before } from 'mocha' +import * as assert from 'assert' +const config = require('../../src/config') +const PhpAnalyzer = require('../../src/engine/analyzer/php/common/php-analyzer') +const { recordFindingStr } = require('../test-utils') +const _ = require('lodash') +const { handleException } = require('../../src/engine/analyzer/common/exception-handler') +const OutputStrategyAutoRegister = require('../../src/engine/analyzer/common/output-strategy-auto-register') +const { execute } = require('../../src/interface/starter') +const logger = require('../../src/util/logger')(__filename) + +const taint_flow_name = ['taint_flow_test', 'taintflow'] + +/** 测试单元：单文件或跨文件目录 */ +interface TestUnit { + type: 'file' | 'dir' + path: string + /** 从 /benchmarks 截取的相对标签，用作 Map key */ + label: string +} + +/** + * 递归扫描 benchmarks 目录，返回混合测试单元列表。 + * - 以 _T.php / _F.php 结尾的文件 → file 型 + * - 以 _T/ / _F/ 结尾且含 .php 的目录 → dir 型（内部 .php 不再单独作为 case） + */ +function getAllTestUnits(rootDir: string): TestUnit[] { + const units: TestUnit[] = [] + + function scan(dir: string): void { + let entries: string[] + try { + entries = fs.readdirSync(dir) + } catch (e) { + handleException(e, 'Error occurred in test-php-benchmark.scan', 'Error occurred in test-php-benchmark.scan') + return + } + + for (const entry of entries) { + const fullPath = path.join(dir, entry) + let stat: fs.Stats | undefined + try { + stat = fs.lstatSync(fullPath) + } catch (e) { + handleException(e, 'Error occurred in test-php-benchmark.scan', 'Error occurred in test-php-benchmark.scan') + continue + } + if (!stat) continue + + if (stat.isDirectory()) { + // 目录名以 _T 或 _F 结尾，且内含 .php → 跨文件目录型 case + if (/_[TF]$/.test(entry) && hasPhpFile(fullPath)) { + const label = fullPath.substring(fullPath.lastIndexOf('/benchmarks')) + units.push({ type: 'dir', path: fullPath, label }) + } else { + scan(fullPath) + } + } else if (stat.isFile() && /_(T|F)\.php$/.test(entry)) { + const label = fullPath.substring(fullPath.lastIndexOf('/benchmarks')).replace(/\.php$/, '') + units.push({ type: 'file', path: fullPath, label }) + } + } + } + + scan(rootDir) + return units +} + +/** 判断目录内是否包含 .php 文件 */ +function hasPhpFile(dir: string): boolean { + try { + const entries = fs.readdirSync(dir) + return entries.some((e: string) => e.endsWith('.php')) + } catch { + return false + } +} + +function recordFinding(finding: any, filename: string, findingResMap: Map): void { + const keyname = filename.substring(filename.lastIndexOf('/benchmarks')) + for (const ruleName of taint_flow_name) { + if (!finding || Object.keys(finding).length === 0) { + findingResMap.set(keyname, { [ruleName]: 0 }) + continue + } + if (finding[ruleName]) { + findingResMap.set(keyname, { [ruleName]: finding[ruleName].length }) + } + } +} + +function statisticImpactArea(findingResMap: Map): string { + let { TP, TN, FP, FN, tpChainNum, tnChainNum, unknown } = getTFPN(findingResMap) + let loginfo: string[] = [] + + const total = TP.size + TN.size + FP.size + FN.size + const precision = TP.size + TN.size > 0 ? (TP.size / (TP.size + TN.size) * 100).toFixed(2) : '0.00' + const recall = TP.size + FP.size > 0 ? (TP.size / (TP.size + FP.size) * 100).toFixed(2) : '0.00' + + loginfo.push('='.repeat(50)) + loginfo.push(`回归case总数:${findingResMap.size}`) + loginfo.push(`统计case总数:${total}`) + loginfo.push(`已检出(TP+TN)的链路数量(含误报):${tpChainNum + tnChainNum}`) + loginfo.push(`未检出(FP+FN)(含待完善):${FP.size + FN.size}`) + loginfo.push('-'.repeat(50)) + loginfo.push(`TP(阳性检出):${TP.size} TN(阴性误报):${TN.size} FP(阳性未检出):${FP.size} FN(阴性正确):${FN.size}`) + loginfo.push(`Precision(精确率): ${precision}%`) + loginfo.push(`Recall(召回率): ${recall}%`) + loginfo.push('-'.repeat(50)) + loginfo.push(`待完善的case数量: 未适配(FP):${FP.size}，误报数(TN):${TN.size} 共计(FP+TN):${FP.size + TN.size}`) + loginfo.push(`待适配的case(FP):\n${Array.from(FP).join('\n')}`) + loginfo.push(`误报case(TN):\n${Array.from(TN).join('\n')}`) + loginfo.push(`未知case:${Array.from(unknown).join('\n')}，数量为${unknown.size}`) + loginfo.push('-'.repeat(50)) + loginfo.push('='.repeat(50)) + + const showstr = loginfo.join('\n') + return showstr +} + +function getTFPN(findingResMap: Map): { + TP: Set + TN: Set + FP: Set + FN: Set + tpChainNum: number + tnChainNum: number + unknown: Set +} { + let TP = new Set(), + TN = new Set(), + FP = new Set(), + FN = new Set(), + unknown = new Set() + let tpChainNum = 0, + tnChainNum = 0 + findingResMap.forEach((value, key) => { + if (!/_T|_F/.test(key)) { + taint_flow_name.forEach((ruleName) => { + if (value[ruleName] && value[ruleName] > 0) { + TP.add(key) + tpChainNum += value[ruleName] + } + }) + if (!TP.has(key)) { + FN.add(key) + } + } else { + if (key.includes('_T')) { + // _T 代表阳性样本 + taint_flow_name.forEach((ruleName) => { + if (value[ruleName] && value[ruleName] > 0) { + TP.add(key) + tpChainNum += value[ruleName] + } + }) + if (!TP.has(key)) { + // 阳性未检出 + FP.add(key) + } + } else if (key.includes('_F')) { + // _F 代表阴性样本 + taint_flow_name.forEach((ruleName) => { + if (value[ruleName] && value[ruleName] > 0) { + // 阴性被检出 = 误报 + TN.add(key) + tnChainNum += value[ruleName] + } + }) + if (!TN.has(key)) { + // 阴性正确未检出 + FN.add(key) + } + } else { + unknown.add(key) + } + } + }) + return { TP, TN, FP, FN, tpChainNum, tnChainNum, unknown } +} + +async function runSingleTest(casePath: string, actualResMap: Map, outputStrategyAutoRegister: any): Promise> { + config.ruleConfigFile = __dirname + '/rule_config.json' + config.checkerIds = ['taint_flow_test', 'sanitizer'] + config.language = 'php' + config.maindirPrefix = __dirname + '/benchmarks' + + const code = fs.readFileSync(casePath).toString() + const recorder = recordFindingStr() + const filename = casePath.substring(casePath.lastIndexOf('/benchmarks')).replace(/\.php$/g, '') + const analyzer = new PhpAnalyzer({ + language: 'php', + examineIssues: true, + checkers: { + taint_flow_test: true, + sanitizer: true, + }, + ...config, + mode: { intra: true }, + sanity: true, + }) + const findingRes = await analyzer.analyzeSingleFile(code, casePath) + if (findingRes) { + const { resultManager } = analyzer.getCheckerManager() + const allFindings = resultManager.getFindings() + if (_.isEmpty(allFindings)) { + recorder.printAndAppend('\n======================== Findings ======================== ') + recorder.printAndAppend('No findings!') + recorder.printAndAppend('========================================================== \n') + } + for (const outputStrategyId in allFindings) { + const strategy = outputStrategyAutoRegister.getStrategy(outputStrategyId) + if (strategy && typeof strategy.outputFindings === 'function') { + strategy.outputFindings(resultManager, strategy.getOutputFilePath(), config, recorder.printAndAppend) + } + } + recordFinding(findingRes, filename, actualResMap) + } else { + recordFinding(null, filename, actualResMap) + } + return { [filename]: recorder.getFormatResult() } +} + +/** + * 以项目模式（execute）运行跨文件目录型 case，提取 taint_flow_test/taintflow 结果数。 + * 参照 Python benchmark 的 execute(null, args) 调用方式。 + */ +async function runDirectoryTest( + dirPath: string, + label: string, + actualResMap: Map, + _outputStrategyAutoRegister: any +): Promise> { + const ruleConfigFile = __dirname + '/rule_config.json' + const reportDir = path.join(__dirname, 'report') + const recorder = recordFindingStr() + + const args: string[] = [ + dirPath, + '--ruleConfigFile', ruleConfigFile, + '--analyzer', 'PhpAnalyzer', + '--checkerIds', 'taint_flow_test,sanitizer', + '--report', reportDir, + ] + + try { + const allFindings = await execute(null, args, recorder.printAndAppend) + const findingRecord: Record = {} + if (allFindings && typeof allFindings === 'object') { + for (const ruleName of taint_flow_name) { + if (allFindings[ruleName] && Array.isArray(allFindings[ruleName])) { + findingRecord[ruleName] = allFindings[ruleName].length + } else { + findingRecord[ruleName] = 0 + } + } + } else { + findingRecord['taint_flow_test'] = 0 + } + actualResMap.set(label, findingRecord) + } catch (e) { + handleException( + e, + `[PHP Benchmark] 目录分析失败: ${label}`, + `[PHP Benchmark] 目录分析失败: ${label}` + ) + actualResMap.set(label, { taint_flow_test: 0 }) + } + + return { [label]: recorder.getFormatResult() } +} + +async function update(dir: string): Promise { + const casePath = path.join(dir, 'case') + const allUnits = getAllTestUnits(casePath) + const actualRes: Record = {} + const actualResMap = new Map() + const outputStrategyAutoRegister = new OutputStrategyAutoRegister() + outputStrategyAutoRegister.autoRegisterAllStrategies() + + for (const unit of allUnits) { + try { + if (unit.type === 'file') { + const singleRes = await runSingleTest(unit.path, actualResMap, outputStrategyAutoRegister) + Object.assign(actualRes, singleRes) + } else { + const dirRes = await runDirectoryTest(unit.path, unit.label, actualResMap, outputStrategyAutoRegister) + Object.assign(actualRes, dirRes) + } + } catch (e) { + handleException( + e, + `[PHP Benchmark] update 用例执行失败: ${unit.label}`, + `[PHP Benchmark] update 用例执行失败: ${unit.label}` + ) + } + } + + const expectDir = path.join(__dirname, 'expect') + if (!fs.existsSync(expectDir)) { + fs.mkdirSync(expectDir, { recursive: true }) + } + fs.writeFileSync( + path.join(expectDir, 'phpbenchmark-expect.json'), + JSON.stringify(actualRes), + { encoding: 'utf8' } + ) +} + +describe('YASA test All PhpBenchmarks', function () { + this.timeout(600000) + + const phpBenchmarkPath = path.resolve(__dirname, 'benchmarks/sast-php/') + if (!fs.existsSync(phpBenchmarkPath)) return + + const expectPath = path.join(__dirname, 'expect', 'phpbenchmark-expect.json') + const actualRes: Record = {} + const actualResMap = new Map() + + before(async function () { + const casePath = path.join(phpBenchmarkPath, 'case') + if (!fs.existsSync(casePath)) { + throw new Error(`PHP benchmark case 路径不存在: ${casePath}，请先运行 prepare-php-benchmark`) + } + + const allUnits = getAllTestUnits(casePath) + const outputStrategyAutoRegister = new OutputStrategyAutoRegister() + outputStrategyAutoRegister.autoRegisterAllStrategies() + + for (const unit of allUnits) { + try { + if (unit.type === 'file') { + const singleRes = await runSingleTest(unit.path, actualResMap, outputStrategyAutoRegister) + Object.assign(actualRes, singleRes) + } else { + const dirRes = await runDirectoryTest(unit.path, unit.label, actualResMap, outputStrategyAutoRegister) + Object.assign(actualRes, dirRes) + } + } catch (e) { + handleException( + e, + `[PHP Benchmark] 用例执行失败: ${unit.label}`, + `[PHP Benchmark] 用例执行失败: ${unit.label}` + ) + actualResMap.set(unit.label, { taint_flow_test: 0 }) + } + } + }) + + it('准召率统计', function () { + const testReport = statisticImpactArea(actualResMap) + logger.info(testReport) + console.log(testReport) + }) + + if (fs.existsSync(expectPath)) { + const expectedRes = JSON.parse(fs.readFileSync(expectPath).toString()) + let i = 1 + for (const caseKey of Object.keys(expectedRes)) { + it(`${i++}-case:${caseKey}`, function () { + logger.info('expected:\n' + expectedRes[caseKey]) + logger.info('actual:\n' + actualRes[caseKey]) + if (_.has(actualRes, caseKey)) { + assert.strictEqual( + actualRes[caseKey], + expectedRes[caseKey], + `链路${caseKey}实际trace或内容与预期不一致,请核对该链路` + ) + } else { + assert.fail(`链路:${caseKey}不存在！！！需要排查原因`) + } + }) + } + } +}) + +// update(path.resolve(__dirname, 'benchmarks/sast-php/')) diff --git a/test/php/test-php-checker.ts b/test/php/test-php-checker.ts new file mode 100644 index 00000000..e0dfe622 --- /dev/null +++ b/test/php/test-php-checker.ts @@ -0,0 +1,193 @@ +import * as path from 'path' +import * as fs from 'fs' +import { describe, it, before } from 'mocha' +import * as assert from 'assert' +const { execute } = require('../../src/interface/starter') +const Config = require('../../src/config') + +const WORKSPACE_ROOT = path.resolve(__dirname, '../..') + '/' +const RULE_CONFIG = path.resolve(WORKSPACE_ROOT, 'resource', 'checker', 'rule_config_php.json') +const DEPS_PATH = path.resolve(WORKSPACE_ROOT, 'deps') +const TEST_CASES_DIR = path.resolve(__dirname, 'checker-cases') + +/** 重置 Config 中 commander 回调会修改的运行时字段，避免跨测试污染 */ +function resetConfig(): void { + Config.dumpCG = false + Config.dumpAllCG = false + Config.dumpAST = false + Config.dumpAllAST = false + Config.single = false + Config.checkerIds = [] + Config.checkerPackIds = [] + Config.ruleConfigFile = '' + Config.reportDir = '' + Config.language = undefined + Config.uastSDKPath = undefined +} + +/** 等待异步流写入完成（createWriteStream 无 await，需轮询） */ +function waitForFile(filePath: string, timeoutMs = 5000, intervalMs = 50): Promise { + return new Promise((resolve, reject) => { + const start = Date.now() + const check = (): void => { + if (fs.existsSync(filePath) && fs.statSync(filePath).size > 0) { + resolve() + } else if (Date.now() - start > timeoutMs) { + reject(new Error(`等待文件超时: ${filePath}`)) + } else { + setTimeout(check, intervalMs) + } + } + check() + }) +} + +function readScanSummary(reportDir: string): any { + const summaryPath = path.join(reportDir, 'scan_summary.json') + if (!fs.existsSync(summaryPath)) return null + return JSON.parse(fs.readFileSync(summaryPath, 'utf-8')) +} + +describe('PHP Checker Regression Tests', function () { + this.timeout(0) + + // ============= Taint Checker ============= + describe('Taint Checker (taint-flow-php-default)', function () { + const reportDir = path.resolve('/tmp', 'php-checker-test-taint') + let summary: any + + before(async function () { + if (fs.existsSync(reportDir)) { + fs.rmSync(reportDir, { recursive: true }) + } + resetConfig() + await execute(null, [ + TEST_CASES_DIR, + '--ruleConfigFile', RULE_CONFIG, + '--checkerPackIds', 'taint-flow-php-default', + '--language', 'php', + '--uastSDKPath', DEPS_PATH, + '--report', reportDir, + ]) + summary = readScanSummary(reportDir) + }) + + it('should produce scan_summary.json', function () { + assert.ok(summary, 'scan_summary.json 未生成') + }) + + it('should detect PHP files', function () { + assert.ok(summary.fileCount >= 4, `文件数不足: ${summary.fileCount}`) + }) + + it('should mark sources (>= 1)', function () { + assert.ok(summary.markedSourceCount >= 1, `Sources marked: ${summary.markedSourceCount}`) + }) + + it('should find taint findings (>= 1)', function () { + assert.ok(summary.findingCount >= 1, `Findings: ${summary.findingCount}，期望 >= 1`) + }) + + it('should have valid entrypoints', function () { + assert.ok(summary.entryPointCount >= 1, `Entrypoints: ${summary.entryPointCount}`) + }) + }) + + // ============= Callchain Checker ============= + describe('Callchain Checker (callchain-php)', function () { + const reportDir = path.resolve('/tmp', 'php-checker-test-callchain') + let summary: any + + before(async function () { + if (fs.existsSync(reportDir)) { + fs.rmSync(reportDir, { recursive: true }) + } + resetConfig() + await execute(null, [ + TEST_CASES_DIR, + '--ruleConfigFile', RULE_CONFIG, + '--checkerPackIds', 'callchain-php', + '--language', 'php', + '--uastSDKPath', DEPS_PATH, + '--report', reportDir, + ]) + summary = readScanSummary(reportDir) + }) + + it('should produce scan_summary.json', function () { + assert.ok(summary, 'scan_summary.json 未生成') + }) + + it('should detect PHP files', function () { + assert.ok(summary.fileCount >= 4, `文件数不足: ${summary.fileCount}`) + }) + + it('should complete without error', function () { + assert.ok(summary.totalTimeMs >= 0, '执行异常') + }) + }) + + // ============= dumpCG ============= + describe('dumpCG (callgraph)', function () { + const reportDir = path.resolve('/tmp', 'php-checker-test-dumpcg') + + before(async function () { + if (fs.existsSync(reportDir)) { + fs.rmSync(reportDir, { recursive: true }) + } + resetConfig() + await execute(null, [ + TEST_CASES_DIR, + '--dumpCG', + '--language', 'php', + '--uastSDKPath', DEPS_PATH, + '--report', reportDir, + '--ruleConfigFile', RULE_CONFIG, + '--checkerPackIds', 'callchain-php', + ]) + // callgraph 使用 createWriteStream 异步写入，等待流刷盘 + await waitForFile(path.join(reportDir, 'callgraph.json')) + }) + + it('should produce callgraph.json', function () { + const cgPath = path.join(reportDir, 'callgraph.json') + assert.ok(fs.existsSync(cgPath), 'callgraph.json 未生成') + }) + + it('should have nodes in callgraph', function () { + const cgPath = path.join(reportDir, 'callgraph.json') + const cg = JSON.parse(fs.readFileSync(cgPath, 'utf-8')) + assert.ok(cg.nodes && Object.keys(cg.nodes).length > 0, 'callgraph 没有 nodes') + }) + }) + + // ============= dumpAllAST ============= + describe('dumpAllAST', function () { + const reportDir = path.resolve('/tmp', 'php-checker-test-dumpast') + + before(async function () { + if (fs.existsSync(reportDir)) { + fs.rmSync(reportDir, { recursive: true }) + } + resetConfig() + await execute(null, [ + TEST_CASES_DIR, + '--dumpAllAST', + '--language', 'php', + '--uastSDKPath', DEPS_PATH, + '--report', reportDir, + ]) + }) + + it('should produce astList.json', function () { + const astListPath = path.join(reportDir, 'astList.json') + assert.ok(fs.existsSync(astListPath), 'astList.json 未生成') + }) + + it('should produce AST JSON files', function () { + const astListPath = path.join(reportDir, 'astList.json') + const astList = JSON.parse(fs.readFileSync(astListPath, 'utf-8')) + assert.ok(Array.isArray(astList) && astList.length > 0, 'AST 文件列表为空') + }) + }) +}) diff --git a/test/python/expect/pythonbenchmark-expect.result b/test/python/expect/pythonbenchmark-expect.result index 72a6479f..ec1043de 100644 --- a/test/python/expect/pythonbenchmark-expect.result +++ b/test/python/expect/pythonbenchmark-expect.result @@ -17,12 +17,6 @@ Trace: /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py AffectedNodeName: taint_src 19: ARG PASS: def type_annotation_new_type_001_T(taint_src): - /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py - AffectedNodeName: process_user - 23: CALL: x = process_user(taint_src , Product("_")) - /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py - AffectedNodeName: user - 20: ARG PASS: def process_user(user: User , product: Product): /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py AffectedNodeName: [return value] 21: Return Value: return user @@ -36,7 +30,7 @@ Trace: AffectedNodeName: taint_sink 24: CALL: taint_sink(x) /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 26: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py AffectedNodeName: os.system @@ -69,7 +63,7 @@ Trace: AffectedNodeName: taint_sink 17: CALL: taint_sink(sum) /case/completeness/single_app_tracing/datatype/primitives/type_annotation_complex_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 19: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/datatype/primitives/type_annotation_complex_001_T.py AffectedNodeName: os.system @@ -309,7 +303,7 @@ Trace: AffectedNodeName: taint_sink 17: CALL: taint_sink(a) /case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 19: ARG PASS: def taint_sink(o): /case/accuracy/context_sensitive/multi_invoke/multi_invoke_001_T.py AffectedNodeName: os.system @@ -338,12 +332,6 @@ Trace: /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py AffectedNodeName: process1 18: CALL RETURN: result = process2(process1(taint_src)) # 污染值传递 - /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py - AffectedNodeName: process2 - 18: CALL: result = process2(process1(taint_src)) # 污染值传递 - /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py - AffectedNodeName: arg - 15: ARG PASS: def process2(arg): /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py AffectedNodeName: [return value] 16: Return Value: return arg @@ -357,7 +345,7 @@ Trace: AffectedNodeName: taint_sink 19: CALL: taint_sink(result) /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 22: ARG PASS: def taint_sink(o): /case/accuracy/context_sensitive/multi_invoke/multi_invoke_003_T.py AffectedNodeName: os.system @@ -471,7 +459,7 @@ Trace: AffectedNodeName: taint_sink 18: CALL: taint_sink(obj.data) /case/accuracy/field_sensitive/class/constructor_field_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 21: ARG PASS: def taint_sink(o): /case/accuracy/field_sensitive/class/constructor_field_003_T.py AffectedNodeName: os.system @@ -527,18 +515,6 @@ Trace: /case/accuracy/field_sensitive/class/field_len_001_T.py AffectedNodeName: taint_src 13: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_001_T.py - AffectedNodeName: __init__ - 14: CALL: self.b = B(taint_src) # 将参数传递给下一层类 - /case/accuracy/field_sensitive/class/field_len_001_T.py - AffectedNodeName: taint_src - 17: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_001_T.py - AffectedNodeName: __init__ - 18: CALL: self.c = C(taint_src) # 继续传递参数到 C - /case/accuracy/field_sensitive/class/field_len_001_T.py - AffectedNodeName: taint_src - 21: ARG PASS: def __init__(self, taint_src): /case/accuracy/field_sensitive/class/field_len_001_T.py AffectedNodeName: self.data 22: Var Pass: self.data = taint_src # 使用参数赋值给 data @@ -555,7 +531,7 @@ Trace: AffectedNodeName: taint_sink 27: CALL: taint_sink(a.b.c.data) # 通过路径访问 data 属性 /case/accuracy/field_sensitive/class/field_len_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 30: ARG PASS: def taint_sink(o): /case/accuracy/field_sensitive/class/field_len_001_T.py AffectedNodeName: os.system @@ -578,36 +554,6 @@ Trace: /case/accuracy/field_sensitive/class/field_len_003_T.py AffectedNodeName: taint_src 13: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: __init__ - 14: CALL: self.b = B(taint_src) # 传递参数到 B - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: taint_src - 17: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: __init__ - 18: CALL: self.c = C(taint_src) # 传递参数到 C - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: taint_src - 21: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: __init__ - 22: CALL: self.d = D(taint_src) # 传递参数到 D - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: taint_src - 25: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: __init__ - 26: CALL: self.e = E(taint_src) # 传递参数到 E - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: taint_src - 29: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: __init__ - 30: CALL: self.f = F(taint_src) # 传递参数到 F - /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: taint_src - 33: ARG PASS: def __init__(self, taint_src): /case/accuracy/field_sensitive/class/field_len_003_T.py AffectedNodeName: self.data 34: Var Pass: self.data = taint_src # 污染数据 @@ -639,7 +585,7 @@ Trace: AffectedNodeName: taint_sink 41: CALL: taint_sink(s1) # 传递污染数据 /case/accuracy/field_sensitive/class/field_len_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 44: ARG PASS: def taint_sink(o): /case/accuracy/field_sensitive/class/field_len_003_T.py AffectedNodeName: os.system @@ -662,72 +608,6 @@ Trace: /case/accuracy/field_sensitive/class/field_len_005_T.py AffectedNodeName: taint_src 13: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 14: CALL: self.b = B(taint_src) # 传递参数到 B - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 17: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 18: CALL: self.c = C(taint_src) # 传递参数到 C - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 21: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 22: CALL: self.d = D(taint_src) # 传递参数到 D - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 25: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 26: CALL: self.e = E(taint_src) # 传递参数到 E - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 29: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 30: CALL: self.f = F(taint_src) # 传递参数到 F - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 33: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 34: CALL: self.g = G(taint_src) # 传递参数到 G - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 37: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 38: CALL: self.h = H(taint_src) # 传递参数到 H - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 41: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 42: CALL: self.i = I(taint_src) # 传递参数到 I - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 45: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 46: CALL: self.j = J(taint_src) # 传递参数到 J - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 49: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 50: CALL: self.k = K(taint_src) # 传递参数到 K - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 53: ARG PASS: def __init__(self, taint_src): - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: __init__ - 54: CALL: self.l = L(taint_src) # 传递参数到 L - /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: taint_src - 57: ARG PASS: def __init__(self, taint_src): /case/accuracy/field_sensitive/class/field_len_005_T.py AffectedNodeName: self.data 58: Var Pass: self.data = taint_src # 污染数据 @@ -771,7 +651,7 @@ Trace: AffectedNodeName: taint_sink 63: CALL: taint_sink(a.b.c.d.e.f.g.h.i.j.k.l.data) # 完整路径访问 a.b.c.d.e.f.g.h.i.j.k.l.data /case/accuracy/field_sensitive/class/field_len_005_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 67: ARG PASS: def taint_sink(o): /case/accuracy/field_sensitive/class/field_len_005_T.py AffectedNodeName: os.system @@ -875,27 +755,6 @@ Trace: ------------- 24: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 -File:/case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py -Line 20: os.system(o) -SINK RULE:os.system -entrypoint: -{"filePath":"/case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py","functionName":"list_mc_006_F","attribute":"fullCallGraphMade","type":"functionCall","funcReceiverType":""} -Trace: - /case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py - AffectedNodeName: taint_src - 13: SOURCE: def list_mc_006_F(taint_src): - /case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py - AffectedNodeName: taint_sink - 16: CALL: taint_sink(arr[0][0]) - /case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py - AffectedNodeName: o - 19: ARG PASS: def taint_sink(o): - /case/accuracy/field_sensitive/multidimensional_collection/list_mc_006_F.py - AffectedNodeName: os.system - 20: SINK: os.system(o) - -------------- 25: taint_flow_test------------- -Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/field_sensitive/multidimensional_collection/map_mc_001_T.py Line 19: os.system(o) SINK RULE:os.system @@ -918,7 +777,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 26: taint_flow_test------------- +------------- 25: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/field_sensitive/multidimensional_collection/map_mc_003_T.py Line 21: os.system(o) @@ -948,7 +807,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 27: taint_flow_test------------- +------------- 26: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/flow_sensitive/asynchronous/asynchronous_chain_001_T.py Line 28: os.system(o) @@ -993,7 +852,7 @@ Trace: AffectedNodeName: os.system 28: SINK: os.system(o) -------------- 28: taint_flow_test------------- +------------- 27: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/flow_sensitive/asynchronous/asyncio_await_001_T.py Line 22: os.system(o) @@ -1029,7 +888,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 29: taint_flow_test------------- +------------- 28: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/flow_sensitive/loop_stmt/for_enumerate_001_T.py Line 17: os.system(o) @@ -1050,7 +909,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 30: taint_flow_test------------- +------------- 29: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/flow_sensitive/loop_stmt/for_zip_001_T.py Line 17: os.system(o) @@ -1071,7 +930,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 31: taint_flow_test------------- +------------- 30: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/flow_sensitive/normal_stmt/assign_expression_stmt_001_T.py Line 18: os.system(o) @@ -1095,7 +954,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 32: taint_flow_test------------- +------------- 31: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/object_sensitive/class/constructor_object_sensitive_001_T.py Line 23: os.system(o.data) @@ -1122,13 +981,13 @@ Trace: AffectedNodeName: taint_sink 19: CALL: taint_sink(obj) # 传递污染源实例 obj /case/accuracy/object_sensitive/class/constructor_object_sensitive_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 22: ARG PASS: def taint_sink(o): /case/accuracy/object_sensitive/class/constructor_object_sensitive_001_T.py AffectedNodeName: os.system 23: SINK: os.system(o.data) -------------- 33: taint_flow_test------------- +------------- 32: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/object_sensitive/class/constructor_object_sensitive_003_T.py Line 29: os.system(o.data) @@ -1155,13 +1014,13 @@ Trace: AffectedNodeName: taint_sink 25: CALL: taint_sink(parent_tainted) # 传递污染的父类对象 /case/accuracy/object_sensitive/class/constructor_object_sensitive_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 28: ARG PASS: def taint_sink(o): /case/accuracy/object_sensitive/class/constructor_object_sensitive_003_T.py AffectedNodeName: os.system 29: SINK: os.system(o.data) -------------- 34: taint_flow_test------------- +------------- 33: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/object_sensitive/collection/array_object_sensitive_001_T.py Line 21: os.system(.join(o)) @@ -1188,6 +1047,30 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(''.join(o)) +------------- 34: taint_flow_test------------- +Description:taint_flow_test，回归测试使用，不推荐外部使用 +File:/case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py +Line 25: os.system(.join(o)) +SINK RULE:os.system +entrypoint: +{"filePath":"/case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py","functionName":"array_object_sensitive_003_T","attribute":"fullCallGraphMade","type":"functionCall","funcReceiverType":""} +Trace: + /case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py + AffectedNodeName: taint_src + 14: SOURCE: def array_object_sensitive_003_T(taint_src): + /case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py + AffectedNodeName: char_array + 16: Var Pass: char_array = array.array('u', taint_src) # 每个字符作为独立元素 + /case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py + AffectedNodeName: taint_sink + 22: CALL: taint_sink(s) + /case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py + AffectedNodeName: o + 24: ARG PASS: def taint_sink(o): + /case/accuracy/object_sensitive/collection/array_object_sensitive_003_T.py + AffectedNodeName: os.system + 25: SINK: os.system(''.join(o)) + ------------- 35: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/accuracy/object_sensitive/collection/list_object_sensitive_001_T.py @@ -1647,7 +1530,7 @@ Trace: AffectedNodeName: taint_sink 22: CALL: taint_sink(getattr(obj, 'name')) /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 19: ARG PASS: def taint_sink(o): /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_002_T.py AffectedNodeName: os.system @@ -1680,7 +1563,7 @@ Trace: AffectedNodeName: taint_sink 21: CALL: taint_sink(getattr(obj, 'foo')) /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_004_F.py - AffectedNodeName: o + AffectedNodeName: taint_sink 24: ARG PASS: def taint_sink(o): /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_004_F.py AffectedNodeName: os.system @@ -1713,7 +1596,7 @@ Trace: AffectedNodeName: taint_sink 21: CALL: taint_sink(getattr(obj, 'data')) /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_006_F.py - AffectedNodeName: o + AffectedNodeName: taint_sink 24: ARG PASS: def taint_sink(o): /case/completeness/dynamic_tracing/dynamic_call/dynamic_call_reflect_006_F.py AffectedNodeName: os.system @@ -3024,6 +2907,12 @@ Trace: /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py AffectedNodeName: [return value] 18: Return Value: yield "suffix" + /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py + AffectedNodeName: process + 24: CALL: asyncio.run(process()) + /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py + AffectedNodeName: process + 20: ARG PASS: async def process(): /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py AffectedNodeName: async_generator 21: CALL RETURN: async for item in async_generator(): # 使用 AsyncFor 进行异步迭代 @@ -3031,7 +2920,7 @@ Trace: AffectedNodeName: taint_sink 22: CALL: taint_sink(item) /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 26: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/asynchronous_tracing/async_for/async_for_001_T.py AffectedNodeName: os.system @@ -3127,7 +3016,7 @@ Trace: AffectedNodeName: taint_sink 23: CALL: taint_sink(data) /case/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_await_009_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 27: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/asynchronous_tracing/promise_callback_await/asynchronous_await_009_T.py AffectedNodeName: os.system @@ -3150,24 +3039,12 @@ Trace: /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py AffectedNodeName: taint_src 21: ARG PASS: def __init__(self, taint_src): - /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py - AffectedNodeName: __init__ - 22: CALL: a_instance = A(taint_src) - /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py - AffectedNodeName: taint_src - 14: ARG PASS: def __init__(self, taint_src): /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py AffectedNodeName: self.data 15: Var Pass: self.data = taint_src /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py AffectedNodeName: a_instance 22: Var Pass: a_instance = A(taint_src) - /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py - AffectedNodeName: get_data - 23: CALL: self.data = a_instance.get_data() - /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py - AffectedNodeName: a_instance - 23: ARG PASS: self.data = a_instance.get_data() /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py AffectedNodeName: [return value] 18: Return Value: return self.data @@ -3184,7 +3061,7 @@ Trace: AffectedNodeName: taint_sink 26: CALL: taint_sink(obj.data) /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 29: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/complex_object/cross_class_001_T.py AffectedNodeName: os.system @@ -3214,7 +3091,7 @@ Trace: AffectedNodeName: taint_sink 31: CALL: taint_sink(a.topData.data) /case/completeness/single_app_tracing/class/complex_object/cross_class_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 34: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/complex_object/cross_class_003_T.py AffectedNodeName: os.system @@ -3237,24 +3114,12 @@ Trace: /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py AffectedNodeName: data 21: ARG PASS: def __init__(self, data): - /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py - AffectedNodeName: __init__ - 22: CALL: super().__init__(data) - /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py - AffectedNodeName: data - 14: ARG PASS: def __init__(self, data): /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py AffectedNodeName: self.data 15: Var Pass: self.data = data /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py AffectedNodeName: obj 27: Var Pass: obj = Child(taint_src) - /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py - AffectedNodeName: get_child_data - 28: CALL: taint_sink(obj.get_child_data()) # 通过子类方法访问父类属性 - /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py - AffectedNodeName: obj - 28: ARG PASS: taint_sink(obj.get_child_data()) # 通过子类方法访问父类属性 /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py AffectedNodeName: [return value] 25: Return Value: return self.data @@ -3265,7 +3130,7 @@ Trace: AffectedNodeName: taint_sink 28: CALL: taint_sink(obj.get_child_data()) # 通过子类方法访问父类属性 /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 30: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/complex_object/inheritance_class_001_T.py AffectedNodeName: os.system @@ -3282,6 +3147,21 @@ Trace: /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py AffectedNodeName: taint_src 13: SOURCE: def inject_data_new_001_T(taint_src): + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py + AffectedNodeName: __new__ + 20: CALL: obj1 = A(taint_src) + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py + AffectedNodeName: data + 15: ARG PASS: def __new__(cls, data): + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py + AffectedNodeName: instance.data + 17: Var Pass: instance.data = data # 直接在__new__中赋值 + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py + AffectedNodeName: [return value] + 18: Return Value: return instance + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py + AffectedNodeName: __new__ + 20: CALL RETURN: obj1 = A(taint_src) /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py AffectedNodeName: obj1 20: Var Pass: obj1 = A(taint_src) @@ -3289,7 +3169,7 @@ Trace: AffectedNodeName: taint_sink 21: CALL: taint_sink(obj1.data) /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 23: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/complex_object/inject_data_new_001_T.py AffectedNodeName: os.system @@ -3306,6 +3186,21 @@ Trace: /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py AffectedNodeName: taint_src 12: SOURCE: def inject_data_new_003_T(taint_src): + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py + AffectedNodeName: __new__ + 33: CALL: obj1 = ComplexObject(taint_src) + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py + AffectedNodeName: input_data + 24: ARG PASS: def __new__(cls, input_data): + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py + AffectedNodeName: instance.tainted_data + 28: Var Pass: instance.tainted_data = input_data + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py + AffectedNodeName: [return value] + 30: Return Value: return instance + /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py + AffectedNodeName: __new__ + 33: CALL RETURN: obj1 = ComplexObject(taint_src) /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py AffectedNodeName: obj1 33: Var Pass: obj1 = ComplexObject(taint_src) @@ -3316,7 +3211,7 @@ Trace: AffectedNodeName: taint_sink 38: CALL: taint_sink(transformed_data) /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 41: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/complex_object/inject_data_new_003_T.py AffectedNodeName: os.system @@ -3349,7 +3244,7 @@ Trace: AffectedNodeName: taint_sink 18: CALL: taint_sink(obj.data) /case/completeness/single_app_tracing/class/simple_object/simple_object_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 21: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/simple_object/simple_object_001_T.py AffectedNodeName: os.system @@ -3412,7 +3307,7 @@ Trace: AffectedNodeName: taint_sink 26: CALL: taint_sink(int_box.get_content()) /case/completeness/single_app_tracing/class/simple_object/simple_object_005_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 29: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/class/simple_object/simple_object_005_T.py AffectedNodeName: os.system @@ -3879,6 +3774,30 @@ Trace: ------------- 137: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 +File:/case/completeness/single_app_tracing/datatype/array/array_003_T.py +Line 22: os.system(.join(o)) +SINK RULE:os.system +entrypoint: +{"filePath":"/case/completeness/single_app_tracing/datatype/array/array_003_T.py","functionName":"array_003_T","attribute":"fullCallGraphMade","type":"functionCall","funcReceiverType":""} +Trace: + /case/completeness/single_app_tracing/datatype/array/array_003_T.py + AffectedNodeName: taint_src + 13: SOURCE: def array_003_T(taint_src): + /case/completeness/single_app_tracing/datatype/array/array_003_T.py + AffectedNodeName: char_array + 14: Var Pass: char_array = array.array('u', taint_src) # 每个字符作为独立元素 + /case/completeness/single_app_tracing/datatype/array/array_003_T.py + AffectedNodeName: taint_sink + 18: CALL: taint_sink(s) + /case/completeness/single_app_tracing/datatype/array/array_003_T.py + AffectedNodeName: o + 21: ARG PASS: def taint_sink(o): + /case/completeness/single_app_tracing/datatype/array/array_003_T.py + AffectedNodeName: os.system + 22: SINK: os.system(''.join(o)) + +------------- 138: taint_flow_test------------- +Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/array/extslice_001_T.py Line 24: os.system(o) SINK RULE:os.system @@ -3888,6 +3807,12 @@ Trace: /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py AffectedNodeName: taint_src 15: SOURCE: def extslice_001_T(taint_src): + /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py + AffectedNodeName: process + 21: CALL: process() + /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py + AffectedNodeName: process + 16: ARG PASS: def process(): /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py AffectedNodeName: arr 17: Var Pass: arr = np.array([[1, 2, taint_src], [4, 5, 6]]) @@ -3895,13 +3820,13 @@ Trace: AffectedNodeName: taint_sink 19: CALL: taint_sink(arr[0:2, 2][0]) # 假设我们试图从数组中提取可能存在污染的数据 /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 23: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/datatype/array/extslice_001_T.py AffectedNodeName: os.system 24: SINK: os.system(o) -------------- 138: taint_flow_test------------- +------------- 139: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/array/extslice_002_F.py Line 24: os.system(o) @@ -3912,6 +3837,12 @@ Trace: /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py AffectedNodeName: taint_src 15: SOURCE: def extslice_002_F(taint_src): + /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py + AffectedNodeName: process + 21: CALL: process() + /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py + AffectedNodeName: process + 16: ARG PASS: def process(): /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py AffectedNodeName: arr 17: Var Pass: arr = np.array([[1, 2, taint_src], [4, 5, 6]]) @@ -3919,13 +3850,13 @@ Trace: AffectedNodeName: taint_sink 19: CALL: taint_sink(arr[0:2, 2][1]) # 假设我们试图从数组中提取可能存在污染的数据 /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py - AffectedNodeName: o + AffectedNodeName: taint_sink 23: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/datatype/array/extslice_002_F.py AffectedNodeName: os.system 24: SINK: os.system(o) -------------- 139: taint_flow_test------------- +------------- 140: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/array/numpy_array_001_T.py Line 21: os.system(.join(o)) @@ -3949,7 +3880,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(''.join(o)) -------------- 140: taint_flow_test------------- +------------- 141: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytearray/bytearray_001_T.py Line 21: os.system(bytes(o)) @@ -3973,7 +3904,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(bytes(o)) -------------- 141: taint_flow_test------------- +------------- 142: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_003_T.py Line 21: os.system(o) @@ -3997,7 +3928,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 142: taint_flow_test------------- +------------- 143: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_005_T.py Line 22: os.system(str(o)) @@ -4024,7 +3955,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 143: taint_flow_test------------- +------------- 144: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_007_T.py Line 22: os.system(o) @@ -4051,7 +3982,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 144: taint_flow_test------------- +------------- 145: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_009_T.py Line 23: os.system(o) @@ -4078,7 +4009,7 @@ Trace: AffectedNodeName: os.system 23: SINK: os.system(o) -------------- 145: taint_flow_test------------- +------------- 146: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_011_T.py Line 22: os.system(o) @@ -4105,7 +4036,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 146: taint_flow_test------------- +------------- 147: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/bytes/bytes_013_T.py Line 22: os.system(str(o)) @@ -4132,7 +4063,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 147: taint_flow_test------------- +------------- 148: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_001_T.py Line 19: os.system(str(o)) @@ -4156,7 +4087,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 148: taint_flow_test------------- +------------- 149: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_003_T.py Line 17: os.system(str(o)) @@ -4180,7 +4111,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 149: taint_flow_test------------- +------------- 150: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_005_T.py Line 18: os.system(str(o)) @@ -4207,7 +4138,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 150: taint_flow_test------------- +------------- 151: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_006_F.py Line 18: os.system(str(o)) @@ -4234,7 +4165,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 151: taint_flow_test------------- +------------- 152: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_007_T.py Line 19: os.system(str(o)) @@ -4261,7 +4192,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 152: taint_flow_test------------- +------------- 153: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/collections/set_008_F.py Line 19: os.system(str(o)) @@ -4288,7 +4219,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 153: taint_flow_test------------- +------------- 154: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/customize/type_annotation_customize_001_T.py Line 22: os.system(o) @@ -4315,7 +4246,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 154: taint_flow_test------------- +------------- 155: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/list/list_001_T.py Line 18: os.system(str(o)) @@ -4339,7 +4270,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 155: taint_flow_test------------- +------------- 156: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/list/list_003_T.py Line 18: os.system(str(o)) @@ -4363,7 +4294,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 156: taint_flow_test------------- +------------- 157: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/list/list_005_T.py Line 19: os.system(str(o)) @@ -4384,7 +4315,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 157: taint_flow_test------------- +------------- 158: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/list/list_007_T.py Line 20: os.system(o) @@ -4408,7 +4339,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(o) -------------- 158: taint_flow_test------------- +------------- 159: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/list/list_009_T.py Line 23: os.system(o) @@ -4438,7 +4369,7 @@ Trace: AffectedNodeName: os.system 23: SINK: os.system(o) -------------- 159: taint_flow_test------------- +------------- 160: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_001_T.py Line 19: os.system(str(o)) @@ -4462,7 +4393,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 160: taint_flow_test------------- +------------- 161: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_005_T.py Line 22: os.system(str(o)) @@ -4486,7 +4417,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 161: taint_flow_test------------- +------------- 162: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_006_F.py Line 22: os.system(str(o)) @@ -4510,7 +4441,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 162: taint_flow_test------------- +------------- 163: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_007_T.py Line 22: os.system(str(o)) @@ -4534,7 +4465,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 163: taint_flow_test------------- +------------- 164: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_008_F.py Line 22: os.system(str(o)) @@ -4558,7 +4489,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 164: taint_flow_test------------- +------------- 165: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/map/map_009_T.py Line 22: os.system(str(o)) @@ -4588,7 +4519,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 165: taint_flow_test------------- +------------- 166: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py Line 27: os.system(o) @@ -4618,13 +4549,13 @@ Trace: AffectedNodeName: taint_sink 24: CALL: taint_sink(x) /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 26: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/datatype/new_type/type_annotation_new_type_001_T.py AffectedNodeName: os.system 27: SINK: os.system(o) -------------- 166: taint_flow_test------------- +------------- 167: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/bool_001_T.py Line 15: os.system(str(o)) @@ -4645,7 +4576,7 @@ Trace: AffectedNodeName: os.system 15: SINK: os.system(str(o)) -------------- 167: taint_flow_test------------- +------------- 168: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/bool_002_F.py Line 15: os.system(str(o)) @@ -4666,7 +4597,7 @@ Trace: AffectedNodeName: os.system 15: SINK: os.system(str(o)) -------------- 168: taint_flow_test------------- +------------- 169: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/complex_001_T.py Line 16: os.system(str(o)) @@ -4690,7 +4621,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(str(o)) -------------- 169: taint_flow_test------------- +------------- 170: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/complex_003_T.py Line 17: os.system(str(o)) @@ -4717,7 +4648,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 170: taint_flow_test------------- +------------- 171: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/complex_004_F.py Line 17: os.system(str(o)) @@ -4744,7 +4675,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 171: taint_flow_test------------- +------------- 172: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/float_001_T.py Line 16: os.system(str(o)) @@ -4768,7 +4699,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(str(o)) -------------- 172: taint_flow_test------------- +------------- 173: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/int_001_T.py Line 16: os.system(str(o)) @@ -4792,7 +4723,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(str(o)) -------------- 173: taint_flow_test------------- +------------- 174: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/none_001_T.py Line 16: os.system(str(o)) @@ -4816,7 +4747,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(str(o)) -------------- 174: taint_flow_test------------- +------------- 175: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/str_001_T.py Line 16: os.system(o) @@ -4840,7 +4771,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(o) -------------- 175: taint_flow_test------------- +------------- 176: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_bool_001_T.py Line 17: os.system(str(o)) @@ -4864,7 +4795,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 176: taint_flow_test------------- +------------- 177: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_complex_001_T.py Line 20: os.system(str(o)) @@ -4891,7 +4822,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 177: taint_flow_test------------- +------------- 178: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_float_001_T.py Line 17: os.system(str(o)) @@ -4915,7 +4846,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 178: taint_flow_test------------- +------------- 179: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_int_001_T.py Line 18: os.system(str(o)) @@ -4939,7 +4870,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 179: taint_flow_test------------- +------------- 180: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_none_001_T.py Line 21: os.system(o) @@ -4960,7 +4891,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 180: taint_flow_test------------- +------------- 181: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/primitives/type_annotation_str_001_T.py Line 18: os.system(o) @@ -4984,7 +4915,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 181: taint_flow_test------------- +------------- 182: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/tuple/tuple_001_T.py Line 18: os.system(str(o)) @@ -5008,7 +4939,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 182: taint_flow_test------------- +------------- 183: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/datatype/tuple/tuple_003_T.py Line 19: os.system(str(o)) @@ -5035,7 +4966,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 183: taint_flow_test------------- +------------- 184: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/exception_error/exception_throw/exception_try_001_T.py Line 21: os.system(o) @@ -5056,7 +4987,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 184: taint_flow_test------------- +------------- 185: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/assign_expression_001_T.py Line 18: os.system(o) @@ -5080,7 +5011,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 185: taint_flow_test------------- +------------- 186: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_001_T.py Line 18: os.system(o) @@ -5104,7 +5035,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 186: taint_flow_test------------- +------------- 187: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_add_assignment_001_T.py Line 19: os.system(o) @@ -5128,7 +5059,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 187: taint_flow_test------------- +------------- 188: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_bitwise_and_001_T.py Line 19: os.system(str(o)) @@ -5152,7 +5083,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 188: taint_flow_test------------- +------------- 189: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_bitwise_or_001_T.py Line 19: os.system(str(o)) @@ -5176,7 +5107,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 189: taint_flow_test------------- +------------- 190: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_bitwise_xor_001_T.py Line 19: os.system(str(o)) @@ -5200,7 +5131,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 190: taint_flow_test------------- +------------- 191: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_divide_assignment_001_T.py Line 20: os.system(str(o)) @@ -5224,7 +5155,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 191: taint_flow_test------------- +------------- 192: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_division_001_T.py Line 21: os.system(str(o)) @@ -5248,7 +5179,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(str(o)) -------------- 192: taint_flow_test------------- +------------- 193: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_floor_div_case_001_T.py Line 17: os.system(str(o)) @@ -5269,7 +5200,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 193: taint_flow_test------------- +------------- 194: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_floor_division_001_T.py Line 19: os.system(str(o)) @@ -5293,7 +5224,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 194: taint_flow_test------------- +------------- 195: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_left_shift_001_T.py Line 19: os.system(str(o)) @@ -5317,7 +5248,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 195: taint_flow_test------------- +------------- 196: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_matrix_multiplication_001_T.py Line 27: os.system(str(o)) @@ -5344,7 +5275,7 @@ Trace: AffectedNodeName: os.system 27: SINK: os.system(str(o)) -------------- 196: taint_flow_test------------- +------------- 197: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_mod_001_T.py Line 17: os.system(str(o)) @@ -5368,7 +5299,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 197: taint_flow_test------------- +------------- 198: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_modulo_assignment_001_T.py Line 19: os.system(str(o)) @@ -5392,7 +5323,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 198: taint_flow_test------------- +------------- 199: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_mult_001_T.py Line 20: os.system(str(o)) @@ -5416,7 +5347,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 199: taint_flow_test------------- +------------- 200: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_multiply_assignment_001_T.py Line 20: os.system(str(o)) @@ -5440,7 +5371,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 200: taint_flow_test------------- +------------- 201: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_power_assignment_001_T.py Line 19: os.system(str(o)) @@ -5464,7 +5395,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 201: taint_flow_test------------- +------------- 202: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_right_shift_001_T.py Line 19: os.system(str(o)) @@ -5488,7 +5419,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 202: taint_flow_test------------- +------------- 203: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_sub_001_T.py Line 20: os.system(str(o)) @@ -5512,7 +5443,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 203: taint_flow_test------------- +------------- 204: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/binary_expression_subtract_assignment_001_T.py Line 20: os.system(str(o)) @@ -5536,7 +5467,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 204: taint_flow_test------------- +------------- 205: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_and_001_T.py Line 18: os.system(str(o)) @@ -5560,7 +5491,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 205: taint_flow_test------------- +------------- 206: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_lsh_001_T.py Line 18: os.system(str(o)) @@ -5584,7 +5515,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 206: taint_flow_test------------- +------------- 207: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T.py Line 18: os.system(str(o)) @@ -5595,11 +5526,17 @@ Trace: /case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T.py AffectedNodeName: taint_src 12: SOURCE: def bitwise_expression_not_001_T(taint_src): + /case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T.py + AffectedNodeName: taint_sink + 14: CALL: taint_sink(result) + /case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T.py + AffectedNodeName: taint_sink + 17: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_not_001_T.py AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 207: taint_flow_test------------- +------------- 208: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_or_001_T.py Line 18: os.system(str(o)) @@ -5623,7 +5560,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 208: taint_flow_test------------- +------------- 209: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_rsh_001_T.py Line 18: os.system(str(o)) @@ -5647,7 +5584,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 209: taint_flow_test------------- +------------- 210: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/bitwise_expression_xor_001_T.py Line 18: os.system(str(o)) @@ -5671,7 +5608,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 210: taint_flow_test------------- +------------- 211: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/greater_than_equal_001_T.py Line 19: os.system(str(o)) @@ -5695,7 +5632,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 211: taint_flow_test------------- +------------- 212: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/less_than_equal_001_T.py Line 19: os.system(str(o)) @@ -5719,7 +5656,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 212: taint_flow_test------------- +------------- 213: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_001_F.py Line 18: os.system(str(o)) @@ -5743,7 +5680,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 213: taint_flow_test------------- +------------- 214: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_and_002_T.py Line 18: os.system(o) @@ -5767,7 +5704,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 214: taint_flow_test------------- +------------- 215: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_001_T.py Line 18: os.system(o) @@ -5791,7 +5728,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 215: taint_flow_test------------- +------------- 216: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/logic_expression_or_002_F.py Line 18: os.system(o) @@ -5815,7 +5752,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 216: taint_flow_test------------- +------------- 217: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_001_T.py Line 18: os.system(str(o)) @@ -5839,7 +5776,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 217: taint_flow_test------------- +------------- 218: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_equal_002_F.py Line 18: os.system(str(o)) @@ -5863,7 +5800,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 218: taint_flow_test------------- +------------- 219: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_001_T.py Line 18: os.system(str(o)) @@ -5887,7 +5824,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 219: taint_flow_test------------- +------------- 220: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_greater_002_F.py Line 18: os.system(str(o)) @@ -5911,7 +5848,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 220: taint_flow_test------------- +------------- 221: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_in_001_T.py Line 20: os.system(str(o)) @@ -5935,7 +5872,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 221: taint_flow_test------------- +------------- 222: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_in_002_F.py Line 20: os.system(str(o)) @@ -5959,7 +5896,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 222: taint_flow_test------------- +------------- 223: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_is_001_T.py Line 20: os.system(str(o)) @@ -5983,7 +5920,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 223: taint_flow_test------------- +------------- 224: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_is_002_F.py Line 20: os.system(str(o)) @@ -6007,7 +5944,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 224: taint_flow_test------------- +------------- 225: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_is_not_001_T.py Line 20: os.system(str(o)) @@ -6031,7 +5968,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 225: taint_flow_test------------- +------------- 226: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_is_not_002_F.py Line 20: os.system(str(o)) @@ -6055,7 +5992,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 226: taint_flow_test------------- +------------- 227: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_001_T.py Line 18: os.system(str(o)) @@ -6079,7 +6016,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 227: taint_flow_test------------- +------------- 228: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_less_002_F.py Line 18: os.system(str(o)) @@ -6103,7 +6040,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 228: taint_flow_test------------- +------------- 229: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_not_equal_001_T.py Line 20: os.system(str(o)) @@ -6127,7 +6064,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 229: taint_flow_test------------- +------------- 230: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_not_equal_002_F.py Line 20: os.system(str(o)) @@ -6151,7 +6088,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 230: taint_flow_test------------- +------------- 231: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_not_in_001_T.py Line 20: os.system(str(o)) @@ -6175,7 +6112,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 231: taint_flow_test------------- +------------- 232: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/relation_expression_not_in_002_F.py Line 20: os.system(str(o)) @@ -6199,7 +6136,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 232: taint_flow_test------------- +------------- 233: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_001_T.py Line 19: os.system(str(o)) @@ -6210,11 +6147,17 @@ Trace: /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_001_T.py AffectedNodeName: taint_src 13: SOURCE: def unary_expression_not_001_T(taint_src): + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_001_T.py + AffectedNodeName: taint_sink + 15: CALL: taint_sink(result) + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_001_T.py + AffectedNodeName: taint_sink + 18: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_001_T.py AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 233: taint_flow_test------------- +------------- 234: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_002_F.py Line 19: os.system(str(o)) @@ -6225,11 +6168,17 @@ Trace: /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_002_F.py AffectedNodeName: taint_src 13: SOURCE: def unary_expression_not_002_F(taint_src): + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_002_F.py + AffectedNodeName: taint_sink + 15: CALL: taint_sink(result) + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_002_F.py + AffectedNodeName: taint_sink + 18: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_not_002_F.py AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 234: taint_flow_test------------- +------------- 235: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_uadd_001_T.py Line 19: os.system(str(o)) @@ -6240,11 +6189,17 @@ Trace: /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_uadd_001_T.py AffectedNodeName: taint_src 13: SOURCE: def unary_expression_uadd_001_T(taint_src): + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_uadd_001_T.py + AffectedNodeName: taint_sink + 15: CALL: taint_sink(result) + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_uadd_001_T.py + AffectedNodeName: taint_sink + 18: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_uadd_001_T.py AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 235: taint_flow_test------------- +------------- 236: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_usub_001_T.py Line 19: os.system(str(o)) @@ -6255,11 +6210,17 @@ Trace: /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_usub_001_T.py AffectedNodeName: taint_src 13: SOURCE: def unary_expression_usub_001_T(taint_src): + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_usub_001_T.py + AffectedNodeName: taint_sink + 15: CALL: taint_sink(result) + /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_usub_001_T.py + AffectedNodeName: taint_sink + 18: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/basic_expression_operation/unary_expression_usub_001_T.py AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 236: taint_flow_test------------- +------------- 237: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/conditional_expression/conditional_expression_001_T.py Line 19: os.system(o) @@ -6283,7 +6244,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 237: taint_flow_test------------- +------------- 238: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/conditional_expression/logical_and_001_T.py Line 17: os.system(o) @@ -6307,7 +6268,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 238: taint_flow_test------------- +------------- 239: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/conditional_expression/logical_and_002_F.py Line 17: os.system(o) @@ -6331,7 +6292,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 239: taint_flow_test------------- +------------- 240: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/conditional_expression/logical_or_001_T.py Line 17: os.system(o) @@ -6355,7 +6316,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 240: taint_flow_test------------- +------------- 241: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/conditional_expression/logical_or_002_F.py Line 17: os.system(o) @@ -6379,7 +6340,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 241: taint_flow_test------------- +------------- 242: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T.py Line 26: os.system(o) @@ -6409,13 +6370,13 @@ Trace: AffectedNodeName: taint_sink 23: CALL: taint_sink(result) /case/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 25: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/lambda_expression/lambda_expression_001_T.py AffectedNodeName: os.system 26: SINK: os.system(o) -------------- 242: taint_flow_test------------- +------------- 243: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_001_T.py Line 25: os.system(o) @@ -6445,13 +6406,13 @@ Trace: AffectedNodeName: taint_sink 21: CALL: taint_sink(Employee.lastname) /case/completeness/single_app_tracing/expression/special_expression/del_expression_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 24: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/special_expression/del_expression_001_T.py AffectedNodeName: os.system 25: SINK: os.system(o) -------------- 243: taint_flow_test------------- +------------- 244: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_002_F.py Line 23: os.system(str(o)) @@ -6478,7 +6439,7 @@ Trace: AffectedNodeName: os.system 23: SINK: os.system(str(o)) -------------- 244: taint_flow_test------------- +------------- 245: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_003_T.py Line 19: os.system(str(o)) @@ -6502,7 +6463,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 245: taint_flow_test------------- +------------- 246: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_004_F.py Line 19: os.system(str(o)) @@ -6526,7 +6487,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 246: taint_flow_test------------- +------------- 247: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_005_T.py Line 20: os.system(str(o)) @@ -6550,7 +6511,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 247: taint_flow_test------------- +------------- 248: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_006_F.py Line 20: os.system(str(o)) @@ -6574,7 +6535,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 248: taint_flow_test------------- +------------- 249: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_007_T.py Line 20: os.system(str(o)) @@ -6598,7 +6559,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 249: taint_flow_test------------- +------------- 250: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/del_expression_008_F.py Line 20: os.system(str(o)) @@ -6622,7 +6583,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 250: taint_flow_test------------- +------------- 251: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_001_T.py Line 19: os.system(o) @@ -6649,7 +6610,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 251: taint_flow_test------------- +------------- 252: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_003_T.py Line 21: os.system(o) @@ -6676,7 +6637,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 252: taint_flow_test------------- +------------- 253: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_004_F.py Line 21: os.system(o) @@ -6703,7 +6664,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 253: taint_flow_test------------- +------------- 254: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_005_T.py Line 19: os.system(o) @@ -6730,7 +6691,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 254: taint_flow_test------------- +------------- 255: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/destructuring_assignment_006_F.py Line 19: os.system(o) @@ -6757,7 +6718,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 255: taint_flow_test------------- +------------- 256: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/enum_001_T.py Line 27: os.system(str(o)) @@ -6784,7 +6745,7 @@ Trace: AffectedNodeName: os.system 27: SINK: os.system(str(o)) -------------- 256: taint_flow_test------------- +------------- 257: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/exponentiation_operator_001_T.py Line 17: os.system(str(o)) @@ -6808,7 +6769,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 257: taint_flow_test------------- +------------- 258: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/list_comprehension_001_T.py Line 18: os.system(o) @@ -6832,7 +6793,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 258: taint_flow_test------------- +------------- 259: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/list_comprehension_002_F.py Line 18: os.system(o) @@ -6856,7 +6817,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 259: taint_flow_test------------- +------------- 260: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py Line 21: os.system(o) @@ -6867,6 +6828,12 @@ Trace: /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py AffectedNodeName: taint_src 12: SOURCE: def map_comprehension_001_T(taint_src): + /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py + AffectedNodeName: process + 18: CALL: process() + /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py + AffectedNodeName: process + 13: ARG PASS: def process(): /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py AffectedNodeName: result 15: Var Pass: result = {i: taint_src for i in range(1)} # 简化示例，只循环一次以展示概念 @@ -6874,13 +6841,13 @@ Trace: AffectedNodeName: taint_sink 16: CALL: taint_sink(result[0]) /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 20: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/expression/special_expression/map_comprehension_001_T.py AffectedNodeName: os.system 21: SINK: os.system(o) -------------- 260: taint_flow_test------------- +------------- 261: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/multi_target_assignment_001_T.py Line 22: os.system(o) @@ -6904,7 +6871,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 261: taint_flow_test------------- +------------- 262: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/rest_parameter_001_T.py Line 20: os.system(str(o)) @@ -6931,7 +6898,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(str(o)) -------------- 262: taint_flow_test------------- +------------- 263: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/spread_operator_001_T.py Line 19: os.system(str(o)) @@ -6958,7 +6925,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(str(o)) -------------- 263: taint_flow_test------------- +------------- 264: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/spread_operator_003_T.py Line 26: os.system(str(o)) @@ -6992,7 +6959,7 @@ Trace: AffectedNodeName: os.system 26: SINK: os.system(str(o)) -------------- 264: taint_flow_test------------- +------------- 265: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/spread_operator_005_T.py Line 21: os.system(str(o)) @@ -7019,7 +6986,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(str(o)) -------------- 265: taint_flow_test------------- +------------- 266: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/spread_operator_007_T.py Line 21: os.system(str(o)) @@ -7046,7 +7013,7 @@ Trace: AffectedNodeName: os.system 21: SINK: os.system(str(o)) -------------- 266: taint_flow_test------------- +------------- 267: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/template_literal_001_T.py Line 18: os.system(o) @@ -7070,7 +7037,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 267: taint_flow_test------------- +------------- 268: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/template_literal_003_T.py Line 18: os.system(o) @@ -7094,7 +7061,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 268: taint_flow_test------------- +------------- 269: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/special_expression/template_literal_005_T.py Line 18: os.system(o) @@ -7118,7 +7085,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 269: taint_flow_test------------- +------------- 270: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/bool_conversion_001_T.py Line 18: os.system(str(o)) @@ -7142,7 +7109,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 270: taint_flow_test------------- +------------- 271: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/float_truncate_001_T.py Line 18: os.system(str(o)) @@ -7166,7 +7133,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 271: taint_flow_test------------- +------------- 272: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/int_truncate_001_T.py Line 17: os.system(str(o)) @@ -7190,7 +7157,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(str(o)) -------------- 272: taint_flow_test------------- +------------- 273: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/str_conversion_001_T.py Line 16: os.system(o) @@ -7214,7 +7181,7 @@ Trace: AffectedNodeName: os.system 16: SINK: os.system(o) -------------- 273: taint_flow_test------------- +------------- 274: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/type_cast_001_T.py Line 18: os.system(str(o)) @@ -7238,7 +7205,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 274: taint_flow_test------------- +------------- 275: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/expression/type_cast/type_cast_002_F.py Line 18: os.system(str(o)) @@ -7262,7 +7229,7 @@ Trace: AffectedNodeName: os.system 18: SINK: os.system(str(o)) -------------- 275: taint_flow_test------------- +------------- 276: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_002_T.py Line 17: os.system(o) @@ -7289,7 +7256,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 276: taint_flow_test------------- +------------- 277: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py Line 17: os.system(o) @@ -7300,17 +7267,23 @@ Trace: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py AffectedNodeName: taint_src 12: SOURCE: def anonymous_function_004_T(taint_src): + /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py + AffectedNodeName: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.anonymous_function_004_T. + 14: CALL: process(taint_src, "_") + /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py + AffectedNodeName: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.anonymous_function_004_T. + 13: ARG PASS: process = lambda x, y: taint_sink(taint_src + y) /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py AffectedNodeName: taint_sink 13: CALL: process = lambda x, y: taint_sink(taint_src + y) /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 16: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_004_T.py AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 277: taint_flow_test------------- +------------- 278: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py Line 18: os.system(o) @@ -7321,17 +7294,23 @@ Trace: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py AffectedNodeName: taint_src 13: SOURCE: def anonymous_function_006_T(taint_src): + /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py + AffectedNodeName: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.anonymous_function_006_T. + 14: CALL: (lambda: taint_sink(taint_src))() + /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py + AffectedNodeName: /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.anonymous_function_006_T. + 14: ARG PASS: (lambda: taint_sink(taint_src))() /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py AffectedNodeName: taint_sink 14: CALL: (lambda: taint_sink(taint_src))() /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 17: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_006_T.py AffectedNodeName: os.system 18: SINK: os.system(o) -------------- 278: taint_flow_test------------- +------------- 279: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/anonymous_function_closure/anonymous_function_008_T.py Line 20: os.system(o) @@ -7358,7 +7337,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(o) -------------- 279: taint_flow_test------------- +------------- 280: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_keyword_taint_001_T.py Line 19: os.system(o) @@ -7388,7 +7367,7 @@ Trace: AffectedNodeName: os.system 19: SINK: os.system(o) -------------- 280: taint_flow_test------------- +------------- 281: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_002_T.py Line 23: os.system(o) @@ -7421,7 +7400,7 @@ Trace: AffectedNodeName: os.system 23: SINK: os.system(o) -------------- 281: taint_flow_test------------- +------------- 282: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_normal_value_003_T.py Line 20: os.system(o) @@ -7448,7 +7427,7 @@ Trace: AffectedNodeName: os.system 20: SINK: os.system(o) -------------- 282: taint_flow_test------------- +------------- 283: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_002_T.py Line 23: os.system(o) @@ -7472,7 +7451,7 @@ Trace: AffectedNodeName: os.system 23: SINK: os.system(o) -------------- 283: taint_flow_test------------- +------------- 284: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_004_T.py Line 22: os.system(str(o)) @@ -7496,7 +7475,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(str(o)) -------------- 284: taint_flow_test------------- +------------- 285: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_reference_006_T.py Line 27: os.system(o) @@ -7523,7 +7502,7 @@ Trace: AffectedNodeName: os.system 27: SINK: os.system(o) -------------- 285: taint_flow_test------------- +------------- 286: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_various_types_001_T.py Line 22: os.system(o) @@ -7550,7 +7529,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 286: taint_flow_test------------- +------------- 287: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_various_types_003_T.py Line 22: os.system(o) @@ -7580,7 +7559,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 287: taint_flow_test------------- +------------- 288: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_various_types_005_T.py Line 22: os.system(o) @@ -7610,7 +7589,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 288: taint_flow_test------------- +------------- 289: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/argument_passing/argument_passing_various_types_007_T.py Line 22: os.system(o) @@ -7637,7 +7616,7 @@ Trace: AffectedNodeName: os.system 22: SINK: os.system(o) -------------- 289: taint_flow_test------------- +------------- 290: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T.py Line 17: os.system(o) @@ -7660,6 +7639,12 @@ Trace: /case/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T.py AffectedNodeName: A(taint_sink).set_name(_).clear_name().set_name(ta 13: ARG PASS: A(taint_sink).set_name("_").clear_name().set_name(taint_src).process() + /case/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T.py + AffectedNodeName: process + 13: CALL: A(taint_sink).set_name("_").clear_name().set_name(taint_src).process() + /case/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T.py + AffectedNodeName: process + 33: ARG PASS: def process(self): /case/completeness/single_app_tracing/function_call/chained_call/chained_call_002_T.py AffectedNodeName: taint_sink 34: CALL: self.taint_sink(self.name) # 使用保存的污染接收函数 @@ -7670,7 +7655,7 @@ Trace: AffectedNodeName: os.system 17: SINK: os.system(o) -------------- 290: taint_flow_test------------- +------------- 291: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py Line 32: os.system(o) @@ -7681,17 +7666,23 @@ Trace: /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py AffectedNodeName: taint_src 12: SOURCE: def chained_call_003_T(taint_src): + /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py + AffectedNodeName: process + 28: CALL: add()['multiply']()['process']() + /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py + AffectedNodeName: process + 24: ARG PASS: def process(): /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py AffectedNodeName: taint_sink 25: CALL: taint_sink(taint_src) /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 31: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py AffectedNodeName: os.system 32: SINK: os.system(o) -------------- 291: taint_flow_test------------- +------------- 292: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/chained_call/chained_call_003_T.py Line 32: os.system(o) @@ -7712,7 +7703,7 @@ Trace: AffectedNodeName: os.system 32: SINK: os.system(o) -------------- 292: taint_flow_test------------- +------------- 293: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/decorator_function/abstractmethod_decorator_001_T.py Line 34: os.system(o) @@ -7736,7 +7727,7 @@ Trace: AffectedNodeName: os.system 34: SINK: os.system(o) -------------- 293: taint_flow_test------------- +------------- 294: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/decorator_function/classmethod_decorator_001_T.py Line 28: os.system(o) @@ -7760,7 +7751,7 @@ Trace: AffectedNodeName: os.system 28: SINK: os.system(o) -------------- 294: taint_flow_test------------- +------------- 295: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_001_T.py Line 28: os.system(o) @@ -7771,6 +7762,12 @@ Trace: /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_001_T.py AffectedNodeName: taint_src 20: SOURCE: def dataclass_decorator_001_T(taint_src): + /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_001_T.py + AffectedNodeName: name + 22: Var Pass: product = Product(name=taint_src, price=9.99) + /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_001_T.py + AffectedNodeName: __init__ + 22: CALL: product = Product(name=taint_src, price=9.99) /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_001_T.py AffectedNodeName: product 22: Var Pass: product = Product(name=taint_src, price=9.99) @@ -7784,30 +7781,6 @@ Trace: AffectedNodeName: os.system 28: SINK: os.system(o) -------------- 295: taint_flow_test------------- -Description:taint_flow_test，回归测试使用，不推荐外部使用 -File:/case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py -Line 28: os.system(str(o)) -SINK RULE:os.system -entrypoint: -{"filePath":"/case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py","functionName":"dataclass_decorator_002_F","attribute":"fullCallGraphMade","type":"functionCall","funcReceiverType":""} -Trace: - /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py - AffectedNodeName: taint_src - 20: SOURCE: def dataclass_decorator_002_F(taint_src): - /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py - AffectedNodeName: product - 22: Var Pass: product = Product(name=taint_src, price=9.99) - /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py - AffectedNodeName: taint_sink - 24: CALL: taint_sink(product.price) - /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py - AffectedNodeName: o - 27: ARG PASS: def taint_sink(o): - /case/completeness/single_app_tracing/function_call/decorator_function/dataclass_decorator_002_F.py - AffectedNodeName: os.system - 28: SINK: os.system(str(o)) - ------------- 296: taint_flow_test------------- Description:taint_flow_test，回归测试使用，不推荐外部使用 File:/case/completeness/single_app_tracing/function_call/decorator_function/property_decorator_001_T.py @@ -7954,12 +7927,6 @@ Trace: /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py AffectedNodeName: taint_src 13: ARG PASS: def outer_gen(taint_src): - /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py - AffectedNodeName: my_inner_gen - 14: CALL: inner_gen = my_inner_gen(taint_src) - /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py - AffectedNodeName: t - 18: ARG PASS: def my_inner_gen(t): /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py AffectedNodeName: [return value] 19: Return Value: a = yield t # 污染源通过参数传递 @@ -7988,7 +7955,7 @@ Trace: AffectedNodeName: taint_sink 23: CALL: taint_sink(next(g)) # 跟踪外层生成器的首次 yield /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 26: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/generator_function/generator_function_005_T.py AffectedNodeName: os.system @@ -8105,7 +8072,7 @@ Trace: AffectedNodeName: taint_sink 21: CALL: taint_sink(f(taint_src, '_')()) /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 24: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_002_T.py AffectedNodeName: os.system @@ -8128,12 +8095,6 @@ Trace: /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py AffectedNodeName: a 13: ARG PASS: def f(g, a, b): - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py - AffectedNodeName: g - 14: CALL: return g(a, b) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py - AffectedNodeName: a - 16: ARG PASS: def g(a, b): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py AffectedNodeName: [return value] 18: Return Value: return lambda: a + b + c @@ -8144,7 +8105,7 @@ Trace: AffectedNodeName: taint_sink 20: CALL: taint_sink(f(g, taint_src, '_')()) /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 23: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_004_T.py AffectedNodeName: os.system @@ -8167,18 +8128,6 @@ Trace: /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py AffectedNodeName: a 13: ARG PASS: def f(g, u, a, b): - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py - AffectedNodeName: g - 14: CALL: return g(u, a, b) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py - AffectedNodeName: a - 16: ARG PASS: def g(u, a, b): - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py - AffectedNodeName: u - 18: CALL: return u(a, b, c) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py - AffectedNodeName: a - 20: ARG PASS: def u(a, b, c): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py AffectedNodeName: [return value] 22: Return Value: return a + b + c @@ -8189,7 +8138,7 @@ Trace: AffectedNodeName: taint_sink 26: CALL: taint_sink(f(g, u, taint_src, '_')()) /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 29: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_006_T.py AffectedNodeName: os.system @@ -8231,7 +8180,7 @@ Trace: AffectedNodeName: taint_sink 17: CALL: taint_sink(result) /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 20: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_008_T.py AffectedNodeName: os.system @@ -8254,24 +8203,12 @@ Trace: /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py AffectedNodeName: s 15: ARG PASS: return lambda s: func2(func1(s)) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py - AffectedNodeName: add_prefix - 15: CALL: return lambda s: func2(func1(s)) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py - AffectedNodeName: s - 17: ARG PASS: def add_prefix(s): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py AffectedNodeName: [return value] 18: Return Value: return f"pre_{s}" /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py AffectedNodeName: add_prefix 15: CALL RETURN: return lambda s: func2(func1(s)) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py - AffectedNodeName: add_suffix - 15: CALL: return lambda s: func2(func1(s)) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py - AffectedNodeName: s - 20: ARG PASS: def add_suffix(s): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py AffectedNodeName: [return value] 21: Return Value: return f"{s}_post" @@ -8291,7 +8228,7 @@ Trace: AffectedNodeName: taint_sink 24: CALL: taint_sink(combined) # 输出 "pre___TAINT_SRC_VALUE_post" /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 27: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_010_T.py AffectedNodeName: os.system @@ -8314,12 +8251,6 @@ Trace: /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py AffectedNodeName: args 20: ARG PASS: def process_callback(callback: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R: - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py - AffectedNodeName: to_upper - 21: CALL: return callback(*args, **kwargs) - /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py - AffectedNodeName: s - 24: ARG PASS: def to_upper(s: str) -> str: /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py AffectedNodeName: [return value] 25: Return Value: return s.upper() @@ -8339,7 +8270,7 @@ Trace: AffectedNodeName: taint_sink 29: CALL: taint_sink(result) /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 31: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/higher_order_function/higher_order_function_012_T.py AffectedNodeName: os.system @@ -8386,6 +8317,12 @@ Trace: /case/completeness/single_app_tracing/function_call/library_function/datetime_001_T.py AffectedNodeName: taint_src 14: SOURCE: def datetime_001_T(taint_src): + /case/completeness/single_app_tracing/function_call/library_function/datetime_002_F.py + AffectedNodeName: process + 18: CALL: process(f"2025-03-25") # 输入格式化的日期时间字符串 + /case/completeness/single_app_tracing/function_call/library_function/datetime_002_F.py + AffectedNodeName: process + 14: ARG PASS: def process(time_str): /case/completeness/single_app_tracing/function_call/library_function/datetime_002_F.py AffectedNodeName: dt 15: Var Pass: dt = datetime.strptime(time_str, "%Y-%m-%d") @@ -8393,7 +8330,7 @@ Trace: AffectedNodeName: taint_sink 16: CALL: taint_sink(dt) /case/completeness/single_app_tracing/function_call/library_function/datetime_002_F.py - AffectedNodeName: o + AffectedNodeName: taint_sink 20: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/library_function/datetime_002_F.py AffectedNodeName: os.system @@ -8573,7 +8510,7 @@ Trace: AffectedNodeName: taint_sink 31: CALL: taint_sink(self.get_data()) /case/completeness/single_app_tracing/function_call/override/constructor_extends_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 34: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/override/constructor_extends_001_T.py AffectedNodeName: os.system @@ -8618,7 +8555,7 @@ Trace: AffectedNodeName: taint_sink 28: CALL: taint_sink(self.get_data()) /case/completeness/single_app_tracing/function_call/override/constructor_extends_003_T.py - AffectedNodeName: data + AffectedNodeName: taint_sink 36: ARG PASS: def taint_sink(data): /case/completeness/single_app_tracing/function_call/override/constructor_extends_003_T.py AffectedNodeName: os.system @@ -8699,12 +8636,6 @@ Trace: /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py AffectedNodeName: a 15: ARG PASS: def inner2(a): - /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py - AffectedNodeName: inner1 - 16: CALL: return inner1(a) - /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py - AffectedNodeName: b - 12: ARG PASS: def inner1(b): /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py AffectedNodeName: [return value] 13: Return Value: return b @@ -8724,7 +8655,7 @@ Trace: AffectedNodeName: taint_sink 19: CALL: taint_sink(data) /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 21: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_004_T.py AffectedNodeName: os.system @@ -8760,7 +8691,7 @@ Trace: AffectedNodeName: taint_sink 18: CALL: taint_sink(x) /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_005_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 21: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/function_call/return_value_passing/return_normal_value_passing_005_T.py AffectedNodeName: os.system @@ -8886,6 +8817,12 @@ Trace: /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py AffectedNodeName: taint_src 14: SOURCE: def nonlocal_001_T(taint_src): + /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py + AffectedNodeName: inner_function + 22: CALL: inner_function() # 调用内层函数 + /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py + AffectedNodeName: inner_function + 17: ARG PASS: def inner_function(): /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py AffectedNodeName: x 19: Var Pass: x = taint_src+"inner" # 修改外层作用域中的 x @@ -8893,7 +8830,7 @@ Trace: AffectedNodeName: taint_sink 20: CALL: taint_sink(x) /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 25: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/variable_scope/nonlocal/nonlocal_001_T.py AffectedNodeName: os.system @@ -8925,12 +8862,6 @@ Trace: /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py AffectedNodeName: o 23: Var Pass: o = A(data=taint_src) # 显式传递 taint_src - /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py - AffectedNodeName: get_data - 24: CALL: taint_sink(o.get_data()) - /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py - AffectedNodeName: o - 24: ARG PASS: taint_sink(o.get_data()) /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py AffectedNodeName: [return value] 18: Return Value: return self.__data @@ -8941,7 +8872,7 @@ Trace: AffectedNodeName: taint_sink 24: CALL: taint_sink(o.get_data()) /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py - AffectedNodeName: o + AffectedNodeName: taint_sink 27: ARG PASS: def taint_sink(o): /case/completeness/single_app_tracing/variable_scope/private_variable/private_variable_001_T.py AffectedNodeName: os.system diff --git a/test/python/test-python-benchmark.ts b/test/python/test-python-benchmark.ts index 92ab5284..3ecade98 100644 --- a/test/python/test-python-benchmark.ts +++ b/test/python/test-python-benchmark.ts @@ -1,5 +1,7 @@ import * as path from 'path' import { describe, it } from 'mocha' +// @ts-ignore +import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' const { execute } = require('../../src/interface/starter') const { ErrorCode } = require('../../src/util/error-code') const { recordFindingStr, resolveTestFindingResult, readExpectRes } = require('../test-utils') @@ -14,6 +16,7 @@ function calResult( actualRes: any expectedResMap: Map actualResMap: Map + accuracyStats: AccuracyStats | null }, name: string ): void { @@ -76,6 +79,21 @@ function calResult( }) } } + + it(`trace accuracy`, function () { + const { accuracyStats } = result + if (!accuracyStats) { + this.skip() + return + } + const pct = + accuracyStats.evaluableHops > 0 + ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) + : 'N/A' + logger.info( + `=== Trace Accuracy [Python Benchmark]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` + ) + }) }) } @@ -122,9 +140,11 @@ async function getRunPythonBenchmarkResult( actualRes: any expectedResMap: Map actualResMap: Map + accuracyStats: AccuracyStats | null }> { const ruleConfigFile = __dirname + '/rule_config_xast_python3.json' let expectPath = path.join(path.resolve(dir), '..', '..', 'expect', expectFile) + const reportDir = path.join(__dirname, 'report') const repoName = path.basename(dir) let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map @@ -141,6 +161,8 @@ async function getRunPythonBenchmarkResult( 'taint_flow_test', '--uastSDKPath', path.join(__dirname, '../../deps'), + '--report', + reportDir, ] try { @@ -160,11 +182,20 @@ async function getRunPythonBenchmarkResult( expectedResMap = resolveTestFindingResult(expectedRes) actualResMap = resolveTestFindingResult(actualRes) + // 计算 trace 准确率 + let accuracyStats: AccuracyStats | null = null + const sarifPath = path.join(reportDir, 'report.sarif') + if (fs.existsSync(sarifPath)) { + const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) + accuracyStats = computeAccuracyFromSarif(sarifData) + } + return { expectedRes, actualRes, expectedResMap, actualResMap, + accuracyStats, } } diff --git a/test/rules-basic-handler/test-match-field.ts b/test/rules-basic-handler/test-match-field.ts new file mode 100644 index 00000000..d1e45f07 --- /dev/null +++ b/test/rules-basic-handler/test-match-field.ts @@ -0,0 +1,240 @@ +/** + * matchField 单元测试 + * + * 覆盖 rule_config 中 fsig 字段（用 . 拼接的方法路径）与 AST 节点的匹配规则： + * - Identifier 终止：fsig 最末段匹配 Identifier 名 + * - MemberAccess 链：a.b.c 形态的成员访问 + * - CallExpression 中段：a.b().c 形态的链式调用（本任务新增） + * - 混合：MemberAccess + CallExpression 交替 + * - 通配：`**` 任意前缀、末尾 `*` 前缀匹配 + * - 边界：i === 0 约束，阻止多余前缀被忽略 + */ +import { describe, it } from 'mocha' +import * as assert from 'assert' +import { matchField } from '../../src/checker/common/rules-basic-handler' + +// ========================= AST fixture 构造器 ========================= + +interface AstNode { + type: string + [key: string]: any +} + +function id(name: string): AstNode { + return { type: 'Identifier', name } +} + +function thisExpr(): AstNode { + return { type: 'ThisExpression' } +} + +function member(obj: AstNode, propName: string): AstNode { + return { + type: 'MemberAccess', + object: obj, + property: { name: propName }, + } +} + +function call(callee: AstNode): AstNode { + return { + type: 'CallExpression', + callee, + } +} + +function newExpr(callee: AstNode): AstNode { + return { + type: 'NewExpression', + callee, + } +} + +// ========================= 辅助断言 ========================= + +function matches(node: AstNode, fsig: string): boolean { + const marray = fsig.split('.') + return matchField(node, marray, marray.length - 1) +} + +// ========================= 用例 ========================= + +describe('matchField', () => { + describe('Identifier 终止', () => { + it('fsig "a" 匹配 Identifier a', () => { + assert.strictEqual(matches(id('a'), 'a'), true) + }) + + it('fsig "a" 不匹配 Identifier b', () => { + assert.strictEqual(matches(id('b'), 'a'), false) + }) + + it('fsig "a.b" 不匹配单独 Identifier b（剩余前缀 "a" 未消费）', () => { + assert.strictEqual(matches(id('b'), 'a.b'), false) + }) + }) + + describe('MemberAccess 链', () => { + it('fsig "a.b" 匹配 a.b', () => { + assert.strictEqual(matches(member(id('a'), 'b'), 'a.b'), true) + }) + + it('fsig "a.b.c" 匹配 a.b.c', () => { + assert.strictEqual(matches(member(member(id('a'), 'b'), 'c'), 'a.b.c'), true) + }) + + it('fsig "b.c" 匹配 a.b.c（原 MemberAccess 行为：根 Identifier 约束 i===0，未消费段失败）', () => { + // 经典语义：marray 必须从右到左完整消费到 i===0 + assert.strictEqual(matches(member(member(id('a'), 'b'), 'c'), 'b.c'), false) + }) + + it('fsig "x.b" 不匹配 a.b', () => { + assert.strictEqual(matches(member(id('a'), 'b'), 'x.b'), false) + }) + }) + + describe('CallExpression 中段（本任务新增）', () => { + it('fsig "b.c" 匹配 a.b().c（callee.object=CallExpression，再递归到 Identifier a 的 i===0）', () => { + // AST: MemberAccess(object=CallExpression(callee=MemberAccess(a, b)), property=c) + const node = member(call(member(id('a'), 'b')), 'c') + assert.strictEqual(matches(node, 'b.c'), true) + }) + + it('fsig "a.b.c" 匹配 a.b().c（补齐根变量段）', () => { + const node = member(call(member(id('a'), 'b')), 'c') + assert.strictEqual(matches(node, 'a.b.c'), true) + }) + + it('fsig "b.c" 不匹配 a.c（中间没有 b() 调用）', () => { + assert.strictEqual(matches(member(id('a'), 'c'), 'b.c'), false) + }) + + it('fsig "b.c" 不匹配 a().c（CallExpression.callee 是 Identifier a，不是 b）', () => { + // AST: MemberAccess(object=CallExpression(callee=Identifier a), property=c) + const node = member(call(id('a')), 'c') + assert.strictEqual(matches(node, 'b.c'), false) + }) + + it('fsig "a.c" 匹配 a().c（CallExpression.callee 是 Identifier a，i===0 终止）', () => { + const node = member(call(id('a')), 'c') + assert.strictEqual(matches(node, 'a.c'), true) + }) + + it('fsig "b.c" 匹配 a.b.c（原 MemberAccess 行为保留，不受新分支影响）', () => { + assert.strictEqual(matches(member(member(id('a'), 'b'), 'c'), 'a.b.c'), true) + }) + }) + + describe('混合 MemberAccess + CallExpression', () => { + it('fsig "a.b.c.d" 匹配 a.b().c().d（两次中段调用）', () => { + // AST: member(call(member(call(member(a, b)), c)), d) + const node = member(call(member(call(member(id('a'), 'b')), 'c')), 'd') + assert.strictEqual(matches(node, 'a.b.c.d'), true) + }) + + it('fsig "b.c.d" 匹配 a.b().c().d（CallExpression 中段用尽 fsig，根变量任意）', () => { + const node = member(call(member(call(member(id('a'), 'b')), 'c')), 'd') + assert.strictEqual(matches(node, 'b.c.d'), true) + }) + + it('fsig "x.c.d" 不匹配 a.b().c().d（中段方法名不符）', () => { + const node = member(call(member(call(member(id('a'), 'b')), 'c')), 'd') + assert.strictEqual(matches(node, 'x.c.d'), false) + }) + }) + + describe('通配符', () => { + it('fsig "**" 匹配任何节点（CallExpression 也不例外）', () => { + const node = member(call(member(id('a'), 'b')), 'c') + assert.strictEqual(matches(node, '**'), true) + }) + + it('fsig "**.c" 匹配任意前缀的 .c', () => { + const node = member(call(member(id('a'), 'b')), 'c') + assert.strictEqual(matches(node, '**.c'), true) + }) + + it('fsig "a.b*" 前缀匹配 a.bar（末尾 *）', () => { + assert.strictEqual(matches(member(id('a'), 'bar'), 'a.b*'), true) + }) + + it('fsig "b*.c" 前缀匹配 a.bar().c', () => { + const node = member(call(member(id('a'), 'bar')), 'c') + assert.strictEqual(matches(node, 'b*.c'), true) + }) + }) + + describe('边界：i===0 约束', () => { + it('fsig "c" 不匹配 x().c（i===0 时节点是 MemberAccess 不是 Identifier，终止失败）', () => { + // marray=['c'], 从 MemberAccess(x(), c) 开始匹配 property=c 通过，递归 object=CallExpression, i=-1 + // 此时 i=-1 且 el=undefined，matchPrefix 一律 false + const node = member(call(id('x')), 'c') + assert.strictEqual(matches(node, 'c'), false) + }) + + it('fsig "c" 匹配 Identifier c（i===0 终止）', () => { + assert.strictEqual(matches(id('c'), 'c'), true) + }) + }) + + describe('NewExpression（本任务新增）', () => { + it('N1: fsig "Foo" 匹配 new Foo(x)', () => { + // AST: NewExpression(callee=Identifier('Foo')) + const node = newExpr(id('Foo')) + assert.strictEqual(matches(node, 'Foo'), true) + }) + + it('N2: fsig "*" 匹配 new Foo(x)（单段通配 + 末尾前缀匹配）', () => { + const node = newExpr(id('Foo')) + assert.strictEqual(matches(node, '*'), true) + }) + + it('N3: fsig "java.io.File" 匹配 new java.io.File(x)（FQN 三段）', () => { + // AST: NewExpression(callee=MemberAccess(MemberAccess(Identifier('java'), 'io'), 'File')) + const node = newExpr(member(member(id('java'), 'io'), 'File')) + assert.strictEqual(matches(node, 'java.io.File'), true) + }) + + it('N4: fsig "**.File" 匹配 new java.io.File(x)（** 通配前缀）', () => { + const node = newExpr(member(member(id('java'), 'io'), 'File')) + assert.strictEqual(matches(node, '**.File'), true) + }) + + it('N5: fsig "java.io.File" 不匹配 new File(x)（层数不够）', () => { + const node = newExpr(id('File')) + assert.strictEqual(matches(node, 'java.io.File'), false) + }) + + it('N6: fsig "A.B" 匹配 new A().B(x)（D20 中段 + NewExpression 递归到 Identifier A）', () => { + // AST: CallExpression(callee=MemberAccess(object=NewExpression(callee=Identifier('A')), property='B')) + const node = call(member(newExpr(id('A')), 'B')) + assert.strictEqual(matches(node, 'A.B'), true) + }) + + it('N7: fsig "B" 匹配 new A().B(x)（段用尽即成功，根任意）', () => { + const node = call(member(newExpr(id('A')), 'B')) + assert.strictEqual(matches(node, 'B'), true) + }) + + it('N8: fsig "A" 不匹配 new A().B(x)（段太少 + 根 A 不是尾方法）', () => { + const node = call(member(newExpr(id('A')), 'B')) + assert.strictEqual(matches(node, 'A'), false) + }) + }) + + describe('其它节点类型不变', () => { + it('ThisExpression：fsig "this" 匹配', () => { + assert.strictEqual(matches(thisExpr(), 'this'), true) + }) + + it('Literal：fsig "foo" 匹配 Literal value=foo', () => { + const node = { type: 'Literal', value: 'foo' } as AstNode + assert.strictEqual(matches(node, 'foo'), true) + }) + + it('未知类型返回 false', () => { + const node = { type: 'UnknownType' } as AstNode + assert.strictEqual(matches(node, 'a'), false) + }) + }) +}) diff --git a/test/rules-basic-handler/test-sink-util-new-expr.ts b/test/rules-basic-handler/test-sink-util-new-expr.ts new file mode 100644 index 00000000..a0777c39 --- /dev/null +++ b/test/rules-basic-handler/test-sink-util-new-expr.ts @@ -0,0 +1,142 @@ +/** + * matchSinkAtFuncCallWithCalleeType / matchSinkAtFuncCall 对 NewExpression 的支持单元测试 + * + * 覆盖 D23 构造器 sink 能力在 sink-util 入口层的行为： + * - `new Foo(x)` 的 callee 是 Identifier / MemberAccess，sink-util `callExpr = node.callee || node` 应能透明处理 + * - `matchSinkAtFuncCallWithCalleeType`（Java/PHP 走）：calleeType 基于 `fclos.rtype.definiteType` 做类型收敛 + * - `matchSinkAtFuncCall`（JS 系走）：不读 calleeType，仅按 fsig 匹配 + * + * 关键断言： + * - C1: 精确 fsig 无 calleeType 可命中 new + * - C2: fsig 短名 + calleeType FQN 可命中 new（用 calleeType 收敛类型身份） + * - C3: calleeType 不匹配时，不命中 + * - C4: calleeType "*" 通配时命中 + * - C5: matchSinkAtFuncCall（JS 入口）忽略 calleeType，只要 fsig 命中即中 + */ +import { describe, it } from 'mocha' +import * as assert from 'assert' +const { matchSinkAtFuncCall, matchSinkAtFuncCallWithCalleeType } = require('../../src/checker/taint/common-kit/sink-util') + +// ========================= AST fixture ========================= + +interface AstNode { + type: string + [key: string]: any +} + +function id(name: string): AstNode { + return { type: 'Identifier', name } +} + +function member(obj: AstNode, propName: string): AstNode { + return { + type: 'MemberAccess', + object: obj, + property: { type: 'Identifier', name: propName }, + } +} + +function newExpr(callee: AstNode): AstNode { + return { + type: 'NewExpression', + callee, + arguments: [], + } +} + +// fclos mock：引擎在 processNewObject 时会传入 fclos，其 rtype 记录被构造类的类型信息 +// - sid：简单名（类名），matchSinkAtFuncCallWithCalleeType 分支 3 用于 fsig 匹配 +// - rtype.definiteType：精确类型（FQN 形态），用于 calleeType 收敛 +// - rtype.vagueType：模糊类型，容错分支 +function mockFclosForClass(simpleName: string, fqn: string): any { + return { + sid: simpleName, + rtype: { + definiteType: id(fqn), // prettyPrint(Identifier) 就是 name，可匹配 "java.io.File" 这类字符串 + vagueType: id(simpleName), + }, + } +} + +// ========================= 用例 ========================= + +describe('sink-util × NewExpression', () => { + describe('matchSinkAtFuncCallWithCalleeType（Java/PHP 路径）', () => { + const callInfo = undefined // 不设 argNum，跳过 arg 数量过滤 + + it('C1: 精确 fsig 无 calleeType 可命中 new Foo(x)（走分支 1 prettyPrint 直匹）', () => { + const node = newExpr(id('Foo')) + const fclos = mockFclosForClass('Foo', 'com.x.Foo') + const rules = [{ fsig: 'Foo', args: ['0'], attribute: 'TestSink' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 1) + assert.strictEqual(matched[0].fsig, 'Foo') + }) + + it('C2: fsig 短名 + calleeType FQN 命中 new File(x)（走分支 3 类型收敛）', () => { + // new File(x) 在代码里是短名，但引擎解析后 fclos.rtype.definiteType = "java.io.File" + const node = newExpr(id('File')) + const fclos = mockFclosForClass('File', 'java.io.File') + const rules = [{ fsig: 'File', calleeType: 'java.io.File', args: ['0'], attribute: 'PathTraversal' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 1, `期望命中 File+java.io.File，实际 ${matched.length}`) + }) + + it('C3: calleeType 不匹配时不命中（不同包的同名类不误伤）', () => { + // new File(x) 解析到 com.acme.File（不是 java.io.File），规则要求 java.io.File → 应失配 + const node = newExpr(id('File')) + const fclos = mockFclosForClass('File', 'com.acme.File') + const rules = [{ fsig: 'File', calleeType: 'java.io.File', args: ['0'], attribute: 'PathTraversal' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 0, `期望失配，实际命中 ${matched.length}`) + }) + + it('C4: calleeType "*" 通配任意类型均命中', () => { + const node = newExpr(id('File')) + const fclos = mockFclosForClass('File', 'random.pkg.File') + const rules = [{ fsig: 'File', calleeType: '*', args: ['0'], attribute: 'PathTraversal' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 1) + }) + + it('C5: calleeType 用 endsWith 后缀匹配（短名 calleeType 也能命中 FQN 类型）', () => { + // calleeType: "File" 应能匹配 definiteType "java.io.File"（endsWith ".File"） + const node = newExpr(id('File')) + const fclos = mockFclosForClass('File', 'java.io.File') + const rules = [{ fsig: 'File', calleeType: 'File', args: ['0'], attribute: 'PathTraversal' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 1) + }) + + it('C6: FQN fsig 无需 calleeType（分支 1 prettyPrint 匹配 MemberAccess 链）', () => { + // new java.io.File(x)：callee 是 MemberAccess 链 + const node = newExpr(member(member(id('java'), 'io'), 'File')) + const fclos = mockFclosForClass('File', 'java.io.File') + const rules = [{ fsig: 'java.io.File', args: ['0'], attribute: 'PathTraversal' }] + const matched = matchSinkAtFuncCallWithCalleeType(node, fclos, rules, null, callInfo) + assert.strictEqual(matched.length, 1) + }) + }) + + describe('matchSinkAtFuncCall（JS 系路径，无 calleeType）', () => { + const callInfo = undefined + + it('C7: fsig 匹配构造器，忽略规则里写的 calleeType（JS 入口不读该字段）', () => { + // JS 系 checker 用 matchSinkAtFuncCall，规则里就算写了 calleeType 也不会被检查 + const node = newExpr(id('Foo')) + const fclos = mockFclosForClass('Foo', 'com.x.Foo') + const rules = [{ fsig: 'Foo', calleeType: 'never-matches.Foo', args: ['0'], attribute: 'TestSink' }] + const matched = matchSinkAtFuncCall(node, fclos, rules, callInfo) + // JS 入口只认 fsig，calleeType 被无视 → 仍命中 + assert.strictEqual(matched.length, 1, '期望命中（JS 入口忽略 calleeType）') + }) + + it('C8: fsig 不匹配时即使 JS 入口也不中', () => { + const node = newExpr(id('Foo')) + const fclos = mockFclosForClass('Foo', 'com.x.Foo') + const rules = [{ fsig: 'Bar', args: ['0'], attribute: 'TestSink' }] + const matched = matchSinkAtFuncCall(node, fclos, rules, callInfo) + assert.strictEqual(matched.length, 0, '期望失配') + }) + }) +}) diff --git a/test/trace-accuracy.ts b/test/trace-accuracy.ts new file mode 100644 index 00000000..bd66920c --- /dev/null +++ b/test/trace-accuracy.ts @@ -0,0 +1,200 @@ +import * as fs from 'fs' +import * as path from 'path' + +// ===== SARIF 类型定义 ===== + +interface SarifSnippet { + text: string + affectedNodeName?: string +} + +interface SarifRegion { + startLine: number + startColumn: number + endLine: number + endColumn: number + snippet: SarifSnippet +} + +interface SarifPhysicalLocation { + artifactLocation?: { uri: string } + region: SarifRegion + nodeHash: string +} + +interface SarifFlowLocation { + location: { + message: { text: string } + physicalLocation: SarifPhysicalLocation + } +} + +interface SarifThreadFlow { + locations: SarifFlowLocation[] +} + +interface SarifCodeFlow { + threadFlows: SarifThreadFlow[] +} + +interface SarifResult { + message: { text: string } + codeFlows: SarifCodeFlow[] +} + +interface SarifRun { + results: SarifResult[] +} + +interface SarifReport { + runs: SarifRun[] + version: string +} + +// ===== 准确率统计接口 ===== + +export interface AccuracyStats { + totalFindings: number + evaluableHops: number + accurateHops: number +} + +// ===== 排除逻辑 ===== + +/** + * 判断 affectedNodeName 是否为引擎特殊标记，应排除出准确率计算 + * + * 排除条件：空值、匿名函数、返回值占位符、双下划线前缀的引擎内部标记、构造函数 + */ +function shouldExclude(name: string | undefined): boolean { + return ( + !name || + name.startsWith(' 0 + ? ((stats.accurateHops / stats.evaluableHops) * 100).toFixed(2) + : 'N/A' + + const lines = [ + '=== Trace Accuracy Report ===', + `Total findings: ${stats.totalFindings}`, + `Total evaluable hops: ${stats.evaluableHops}`, + `Accurate hops: ${stats.accurateHops}`, + stats.evaluableHops > 0 + ? `Accuracy: ${stats.accurateHops}/${stats.evaluableHops} = ${accuracy}%` + : 'Accuracy: N/A (no evaluable hops)', + ] + + return lines.join('\n') +} + +// ===== CLI 入口 ===== + +function main(): void { + const args = process.argv.slice(2) + const sarifPath = args[0] || './report/report.sarif' + + const resolvedPath = path.resolve(sarifPath) + + if (!fs.existsSync(resolvedPath)) { + console.log(`No SARIF file found: ${resolvedPath}`) + process.exit(0) + } + + const content = fs.readFileSync(resolvedPath, 'utf-8') + const sarifData: SarifReport = JSON.parse(content) + + const stats = computeAccuracyFromSarif(sarifData) + console.log(formatReport(stats)) +} + +// 仅直接运行时执行 CLI，被 import 时不执行 +if (require.main === module) { + main() +} From cde9a337911280c37fc7a1f4bf0eeb51d77cb3ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Wed, 6 May 2026 18:20:18 +0800 Subject: [PATCH 2/6] sync: update core engine codebase Incremental sync of latest engine code: - Rename PHP analyzer entrypoint collectors to generic naming - Adjust PHP default taint checker accordingly - Update package.json --- package.json | 6 ++-- .../taint/php/php-default-taint-checker.ts | 24 +++++++------- .../custom-databucket-entrypoint.ts} | 31 +++++++++---------- .../custom-mvc-controller-entrypoint.ts} | 26 +++++++--------- 4 files changed, 42 insertions(+), 45 deletions(-) rename src/engine/analyzer/php/{haodf/entrypoint-collector/haodf-databucket-entrypoint.ts => custom/entrypoint-collector/custom-databucket-entrypoint.ts} (82%) rename src/engine/analyzer/php/{haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts => custom/entrypoint-collector/custom-mvc-controller-entrypoint.ts} (75%) diff --git a/package.json b/package.json index ac1beb8a..47713ee6 100644 --- a/package.json +++ b/package.json @@ -5,9 +5,9 @@ "main": "./dist/main.js", "bin": "./dist/main.js", "dependencies": { - "@ant-yasa/uast-parser-java-js": "^0.2.12", - "@ant-yasa/uast-parser-php": "^0.2.12", - "@ant-yasa/uast-spec": "^0.2.12", + "@ant-yasa/uast-parser-java-js": "^0.2.13", + "@ant-yasa/uast-parser-php": "^0.2.13", + "@ant-yasa/uast-spec": "^0.2.13", "@babel/core": "^7.14.6", "@babel/parser": "^7.16.4", "@babel/plugin-proposal-decorators": "^7.14.5", diff --git a/src/checker/taint/php/php-default-taint-checker.ts b/src/checker/taint/php/php-default-taint-checker.ts index a225ce95..2b115059 100644 --- a/src/checker/taint/php/php-default-taint-checker.ts +++ b/src/checker/taint/php/php-default-taint-checker.ts @@ -21,11 +21,11 @@ const { findSoaServiceEntryPoints, } = require('../../../engine/analyzer/php/soa/entrypoint-collector/soa-service-entrypoint') const { - findHaodfMvcControllerEntryPoints, -} = require('../../../engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint') + findCustomMvcControllerEntryPoints, +} = require('../../../engine/analyzer/php/custom/entrypoint-collector/custom-mvc-controller-entrypoint') const { - findHaodfDataBucketEntryPoints, -} = require('../../../engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint') + findCustomDataBucketEntryPoints, +} = require('../../../engine/analyzer/php/custom/entrypoint-collector/custom-databucket-entrypoint') const TaintOutputStrategy = require('../../common/output/taint-output-strategy') const entryPointConfig = require('../../../engine/analyzer/common/current-entrypoint') @@ -88,16 +88,16 @@ class PhpDefaultTaintChecker extends TaintChecker { } } - // Haodf 自研 MVC（avatar 桶）：基于类签名约定识别 - // - HaodfMvcController：controllers/ 下 Controller 后缀/继承 + public + params>=1 action - // - HaodfDataBucket：mobileapi/weixmpapi/wap 的 DataBucket 后缀/继承 + public + params>=1 - // 两者合并 append（单个项目可能同时出现两类，如 wap 既有 Controller 又有 mobileapi/ 子目录 DataBucket） + // 自定义 MVC 框架：基于类签名约定识别 + // - CustomMvcController：controllers/ 下 Controller 后缀/继承 + public + params>=1 action + // - CustomDataBucket：通过 __call 转发的 DataBucket 后缀/继承 + public + params>=1 + // 两者合并 append（单个项目可能同时出现两类，例如既有 Controller 又有 DataBucket 子目录） if (this.entryPoints.length === 0) { - const mvcEntryPoints = findHaodfMvcControllerEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + const mvcEntryPoints = findCustomMvcControllerEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) if (mvcEntryPoints.length > 0) { this.entryPoints.push(...mvcEntryPoints) } - const dataBucketEntryPoints = findHaodfDataBucketEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) + const dataBucketEntryPoints = findCustomDataBucketEntryPoints(analyzer, Config.maindirPrefix || Config.maindir) if (dataBucketEntryPoints.length > 0) { this.entryPoints.push(...dataBucketEntryPoints) } @@ -313,7 +313,7 @@ class PhpDefaultTaintChecker extends TaintChecker { /** * Entrypoint 参数 taint 注入：所有 PHP entrypoint 的入参统一全部标 source - * - SOAService / HaodfDataBucket / HaodfMvcController：所有参数都视为外部输入 + * - SOAService / CustomDataBucket / CustomMvcController：所有参数都视为外部输入 * @param analyzer * @param scope * @param node @@ -323,7 +323,7 @@ class PhpDefaultTaintChecker extends TaintChecker { triggerAtSymbolInterpretOfEntryPointBefore(analyzer: any, scope: any, node: any, state: any, info: any): void { const currentEntryPoint = entryPointConfig.getCurrentEntryPoint() const attr = currentEntryPoint?.attribute - const TAINT_ATTRS = new Set(['SOAService', 'HaodfDataBucket', 'HaodfMvcController']) + const TAINT_ATTRS = new Set(['SOAService', 'CustomDataBucket', 'CustomMvcController']) if (!TAINT_ATTRS.has(attr)) return const epSym = currentEntryPoint.entryPointSymVal const parameters = epSym?.ast?.fdef?.parameters diff --git a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts b/src/engine/analyzer/php/custom/entrypoint-collector/custom-databucket-entrypoint.ts similarity index 82% rename from src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts rename to src/engine/analyzer/php/custom/entrypoint-collector/custom-databucket-entrypoint.ts index d682c15d..a04911e5 100644 --- a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-databucket-entrypoint.ts +++ b/src/engine/analyzer/php/custom/entrypoint-collector/custom-databucket-entrypoint.ts @@ -1,21 +1,20 @@ /** - * Haodf DataBucket entrypoint 采集器 - * - * 适用项目：mobileapi / weixmpapi / wap + * 自定义 DataBucket entrypoint 采集器 * * 背景： - * - mobileapi 的 Controller 层（`MobileApiApp::run` + `BaseController`）通过 `__call` 魔术方法把请求 - * 转发到具体 DataBucket，真正的业务入口是 `controllers//<*>databucket.php` 里的 public 方法。 - * - DataBucket 方法签名不固定（按 RPC 参数逐个展开，如 `($userId, $os, $v)`），不能按 Controller 的 "==2" 判定。 - * - 历史拼写/命名漂移：实际文件后缀存在 `databucket.php / databacket.php / databuck.php / bucket.php` 四种。 + * - 部分 PHP 项目的 Controller 层通过 `__call` 魔术方法把请求转发到具体 DataBucket， + * 真正的业务入口是 `controllers//<*>databucket.php` 里的 public 方法。 + * - DataBucket 方法签名不固定（按 RPC 参数逐个展开，如 `($userId, $os, $v)`）， + * 不能按 Controller 的 "==2" 判定。 + * - 历史拼写/命名漂移：实际文件后缀可能存在 `databucket.php / databacket.php / databuck.php / bucket.php` 多种。 * * 识别策略： - * 1. 类名以 `DataBucket / DataBacket / DataBuck / Bucket` 之一结尾（大小写不敏感），或继承链包含 - * `BaseDataBucket`/`DataBucket` 等基类。 + * 1. 类名以 `DataBucket / DataBacket / DataBuck / Bucket` 之一结尾（大小写不敏感）， + * 或继承链包含 `BaseDataBucket`/`DataBucket` 等基类。 * 2. 方法：public 非魔术，参数数 >= 1（所有参数都当外部输入）。 * 3. 排除 PHP 魔术方法 / setInstance / getInstance / DI 模板。 * - * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='HaodfDataBucket'。 + * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='CustomDataBucket'。 * taint 层把所有参数都当 source（走 SOA 同样的全参污点分支）。 */ const { extractRelativePath } = require('../../../../../util/file-util') @@ -26,14 +25,14 @@ const { buildClassInheritanceMap, EXCLUDED_METHODS, } = require('../../sparta/entrypoint-collector/sparta-default-entrypoint') -const { DI_METHOD_NAMES } = require('./haodf-mvc-controller-entrypoint') +const { DI_METHOD_NAMES } = require('./custom-mvc-controller-entrypoint') const MAX_DEPTH = 10 /** DataBucket 基类名模式（大小写不敏感，endsWith 匹配） */ const DATABUCKET_BASE_PATTERNS = ['basedatabucket', 'databucket', 'basedatabacket', 'databacket'] -/** DataBucket 类名后缀（大小写不敏感，endsWith 匹配）。历史拼写漂移允许 4 种。 */ +/** DataBucket 类名后缀（大小写不敏感，endsWith 匹配）。允许多种历史拼写。 */ const DATABUCKET_SUFFIXES = ['databucket', 'databacket', 'databuck', 'bucket'] /** 基类名——跳过基类本身不当 entrypoint 采集 */ @@ -101,7 +100,7 @@ function isDataBucketMethod(funcDef: any): boolean { * @param analyzer PhpAnalyzer 实例 * @param dir 项目根目录 */ -function findHaodfDataBucketEntryPoints(analyzer: any, dir: string): any[] { +function findCustomDataBucketEntryPoints(analyzer: any, dir: string): any[] { const entryPoints: any[] = [] const moduleScopes: Map = analyzer.moduleScopes || new Map() @@ -142,7 +141,7 @@ function findHaodfDataBucketEntryPoints(analyzer: any, dir: string): any[] { ep.argValues = [] ep.functionName = methodName ep.filePath = shortFileName - ep.attribute = 'HaodfDataBucket' + ep.attribute = 'CustomDataBucket' ep.packageName = undefined ep.entryPointSymVal = methodFclos entryPoints.push(ep) @@ -150,12 +149,12 @@ function findHaodfDataBucketEntryPoints(analyzer: any, dir: string): any[] { } } - logger.info(`[HaodfDataBucket] 发现 ${entryPoints.length} 个 DataBucket entrypoints`) + logger.info(`[CustomDataBucket] 发现 ${entryPoints.length} 个 DataBucket entrypoints`) return entryPoints } module.exports = { - findHaodfDataBucketEntryPoints, + findCustomDataBucketEntryPoints, isDataBucketClass, isDataBucketMethod, } diff --git a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts b/src/engine/analyzer/php/custom/entrypoint-collector/custom-mvc-controller-entrypoint.ts similarity index 75% rename from src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts rename to src/engine/analyzer/php/custom/entrypoint-collector/custom-mvc-controller-entrypoint.ts index 2bfbac28..341559c5 100644 --- a/src/engine/analyzer/php/haodf/entrypoint-collector/haodf-mvc-controller-entrypoint.ts +++ b/src/engine/analyzer/php/custom/entrypoint-collector/custom-mvc-controller-entrypoint.ts @@ -1,19 +1,17 @@ /** - * Haodf 自研 MVC 框架 Controller entrypoint 采集器（路由中立） + * 自定义 MVC 框架 Controller entrypoint 采集器（路由中立） * * 背景： - * - Haodf 自研 MVC（avatar 桶大多数项目）用 `mywebapp.php` 注册路由，但 `FixedRouterRule::create()->url('//')` - * catchall 兜底会把未在 NamedRouterRule 里注册的 public action 也调用到， - * 所以不能用路由白名单做准入门票（会漏），改走"类签名约定"。 + * - 部分 PHP 项目使用 catchall 路由把未在路由表中显式注册的 public action 也调用到， + * 不能用路由白名单做准入门票（会漏），改走"类签名约定"。 * * 识别策略： - * 1. 类名以 `Controller` 结尾（大小写不敏感，如 `Indexcontroller`/`AuditInfocontroller`）， - * 或继承链包含 `BaseController`/`Controller`。 - * 2. 方法：public 非魔术，参数数 >= 1（Haodf 主流 action 签名为 `($request, $response)`， - * 但老代码存在 1 参和 3+ 参的真 action，只排 0 参）。 + * 1. 类名以 `Controller` 结尾（大小写不敏感），或继承链包含 `BaseController`/`Controller`。 + * 2. 方法：public 非魔术，参数数 >= 1（典型 action 签名为 `($request, $response)`， + * 也允许 1 参和 3+ 参的真 action，只排 0 参）。 * 3. 排除 PHP 魔术方法 / setInstance / getInstance / DI 模板。 * - * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='HaodfMvcController'。 + * 产出：完整 EntryPoint（带 entryPointSymVal），attribute='CustomMvcController'。 * taint 层只把第一个参数 `$request` 当 source（`$response` 是输出端）。 */ const { extractRelativePath } = require('../../../../../util/file-util') @@ -30,7 +28,7 @@ const { const DI_METHOD_NAMES = new Set(['setinstance', 'getinstance']) /** - * 判断方法是否为 Haodf MVC Controller 的合法 action + * 判断方法是否为自定义 MVC Controller 的合法 action * - 非魔术 / 非 DI 模板 * - public 或未显式修饰（PHP 默认 public） * - 参数数 >= 1（0 参方法一般是工具函数，不采） @@ -59,7 +57,7 @@ function isMvcActionMethod(funcDef: any): boolean { * @param analyzer PhpAnalyzer 实例 * @param dir 项目根目录 */ -function findHaodfMvcControllerEntryPoints(analyzer: any, dir: string): any[] { +function findCustomMvcControllerEntryPoints(analyzer: any, dir: string): any[] { const entryPoints: any[] = [] const moduleScopes: Map = analyzer.moduleScopes || new Map() @@ -100,7 +98,7 @@ function findHaodfMvcControllerEntryPoints(analyzer: any, dir: string): any[] { ep.argValues = [] ep.functionName = methodName ep.filePath = shortFileName - ep.attribute = 'HaodfMvcController' + ep.attribute = 'CustomMvcController' ep.packageName = undefined ep.entryPointSymVal = methodFclos entryPoints.push(ep) @@ -108,12 +106,12 @@ function findHaodfMvcControllerEntryPoints(analyzer: any, dir: string): any[] { } } - logger.info(`[HaodfMvcController] 发现 ${entryPoints.length} 个 MVC Controller action entrypoints`) + logger.info(`[CustomMvcController] 发现 ${entryPoints.length} 个 MVC Controller action entrypoints`) return entryPoints } module.exports = { - findHaodfMvcControllerEntryPoints, + findCustomMvcControllerEntryPoints, isMvcActionMethod, DI_METHOD_NAMES, } From 552290371f8fefebf527832c8950f594ad58d31a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Wed, 6 May 2026 18:21:27 +0800 Subject: [PATCH 3/6] sync: update core engine codebase --- package-lock.json | 3156 ++++++++++++++++++++------------------------- 1 file changed, 1396 insertions(+), 1760 deletions(-) diff --git a/package-lock.json b/package-lock.json index b8ddfa93..09b6208c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,8 +9,9 @@ "version": "0.0.0", "license": "ISC", "dependencies": { - "@ant-yasa/uast-parser-java-js": "^0.2.9", - "@ant-yasa/uast-spec": "^0.2.9", + "@ant-yasa/uast-parser-java-js": "^0.2.13", + "@ant-yasa/uast-parser-php": "^0.2.13", + "@ant-yasa/uast-spec": "^0.2.13", "@babel/core": "^7.14.6", "@babel/parser": "^7.16.4", "@babel/plugin-proposal-decorators": "^7.14.5", @@ -91,9 +92,9 @@ } }, "node_modules/@ant-yasa/uast-parser-java-js": { - "version": "0.2.9", - "resolved": "https://registry.npmjs.org/@ant-yasa/uast-parser-java-js/-/uast-parser-java-js-0.2.9.tgz", - "integrity": "sha512-fnIKL/xphRiWbfiagzwqNJ0Jahe5UcXzry4HA1Y+kOWhE4kmzxWvX+uEiUMCtE3p8yakSS2AnRlCmNPUVy7Hrw==", + "version": "0.2.13", + "resolved": "https://registry.npmmirror.com/@ant-yasa/uast-parser-java-js/-/uast-parser-java-js-0.2.13.tgz", + "integrity": "sha512-RoX2JNAD0yyVNKxXDYotib2MSY0eaSRWpFQ76Blo5AIB9dt07A1p+WmdT7DmXaw/U82s9Upc4INS+2BkG3BdJg==", "dependencies": { "@ant-yasa/uast-spec": "^0.2.0", "@babel/core": "^7.18.0", @@ -123,7 +124,7 @@ }, "node_modules/@ant-yasa/uast-parser-java-js/node_modules/typescript": { "version": "4.9.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", + "resolved": "https://registry.npmmirror.com/typescript/-/typescript-4.9.5.tgz", "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==", "license": "Apache-2.0", "bin": { @@ -134,10 +135,21 @@ "node": ">=4.2.0" } }, + "node_modules/@ant-yasa/uast-parser-php": { + "version": "0.2.13", + "resolved": "https://registry.npmmirror.com/@ant-yasa/uast-parser-php/-/uast-parser-php-0.2.13.tgz", + "integrity": "sha512-ObtgmQAyFmWowYkGSaDLOCroKIb9K1eVIoXzH8pMCYrVowP8hCXerPjJL9oQREFrohhGddGzQlVs7BlxB47fbw==", + "dependencies": { + "@ant-yasa/uast-spec": "^0.2.0", + "tree-sitter-php": "^0.24.2", + "typescript": "^5.7.2", + "web-tree-sitter": "^0.26.8" + } + }, "node_modules/@ant-yasa/uast-spec": { - "version": "0.2.9", - "resolved": "https://registry.npmjs.org/@ant-yasa/uast-spec/-/uast-spec-0.2.9.tgz", - "integrity": "sha512-y6BexCrO+ztHlxD2zh/SIwSG7YJyPLTFRPV6u8A0r+hmWzFC2PjSK1qyx+q8HWlDlUq59dveX0HchkM11Havrw==", + "version": "0.2.13", + "resolved": "https://registry.npmmirror.com/@ant-yasa/uast-spec/-/uast-spec-0.2.13.tgz", + "integrity": "sha512-DVb744PQ7A1UZKSRahRj/cPqXeBQG5Q+EeQaQ/Ec134unJrrAOoq82mq0uCR8jiR+Xj2WVYl++qD+fJoI1QPoQ==", "dependencies": { "@babel/helper-validator-identifier": "^7.16.7", "fancy-log": "^2.0.0", @@ -151,7 +163,7 @@ }, "node_modules/@ant-yasa/uast-spec/node_modules/typescript": { "version": "4.9.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", + "resolved": "https://registry.npmmirror.com/typescript/-/typescript-4.9.5.tgz", "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==", "license": "Apache-2.0", "bin": { @@ -164,7 +176,7 @@ }, "node_modules/@babel/code-frame": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/code-frame/-/code-frame-7.29.0.tgz", "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", "license": "MIT", "dependencies": { @@ -178,7 +190,7 @@ }, "node_modules/@babel/compat-data": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/compat-data/-/compat-data-7.29.0.tgz", "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", "license": "MIT", "engines": { @@ -187,7 +199,7 @@ }, "node_modules/@babel/core": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/core/-/core-7.29.0.tgz", "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "license": "MIT", "dependencies": { @@ -217,7 +229,7 @@ }, "node_modules/@babel/core/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -226,7 +238,7 @@ }, "node_modules/@babel/generator": { "version": "7.29.1", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/generator/-/generator-7.29.1.tgz", "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", "license": "MIT", "dependencies": { @@ -242,7 +254,7 @@ }, "node_modules/@babel/helper-annotate-as-pure": { "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz", "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==", "license": "MIT", "dependencies": { @@ -254,7 +266,7 @@ }, "node_modules/@babel/helper-compilation-targets": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", "license": "MIT", "dependencies": { @@ -270,7 +282,7 @@ }, "node_modules/@babel/helper-compilation-targets/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -279,7 +291,7 @@ }, "node_modules/@babel/helper-create-class-features-plugin": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz", "integrity": "sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==", "license": "MIT", "dependencies": { @@ -300,7 +312,7 @@ }, "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -309,7 +321,7 @@ }, "node_modules/@babel/helper-create-regexp-features-plugin": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz", "integrity": "sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==", "license": "MIT", "dependencies": { @@ -326,7 +338,7 @@ }, "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -335,7 +347,7 @@ }, "node_modules/@babel/helper-define-polyfill-provider": { "version": "0.6.8", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz", "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==", "license": "MIT", "dependencies": { @@ -351,7 +363,7 @@ }, "node_modules/@babel/helper-globals": { "version": "7.28.0", - "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz", "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", "license": "MIT", "engines": { @@ -360,7 +372,7 @@ }, "node_modules/@babel/helper-member-expression-to-functions": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz", "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==", "license": "MIT", "dependencies": { @@ -373,7 +385,7 @@ }, "node_modules/@babel/helper-module-imports": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", "license": "MIT", "dependencies": { @@ -386,7 +398,7 @@ }, "node_modules/@babel/helper-module-transforms": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", "license": "MIT", "dependencies": { @@ -403,7 +415,7 @@ }, "node_modules/@babel/helper-optimise-call-expression": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz", "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==", "license": "MIT", "dependencies": { @@ -415,7 +427,7 @@ }, "node_modules/@babel/helper-plugin-utils": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", "license": "MIT", "engines": { @@ -424,7 +436,7 @@ }, "node_modules/@babel/helper-remap-async-to-generator": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz", "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==", "license": "MIT", "dependencies": { @@ -441,7 +453,7 @@ }, "node_modules/@babel/helper-replace-supers": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz", "integrity": "sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==", "license": "MIT", "dependencies": { @@ -458,7 +470,7 @@ }, "node_modules/@babel/helper-skip-transparent-expression-wrappers": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz", "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==", "license": "MIT", "dependencies": { @@ -471,7 +483,7 @@ }, "node_modules/@babel/helper-string-parser": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", "license": "MIT", "engines": { @@ -480,7 +492,7 @@ }, "node_modules/@babel/helper-validator-identifier": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", "license": "MIT", "engines": { @@ -489,7 +501,7 @@ }, "node_modules/@babel/helper-validator-option": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", "license": "MIT", "engines": { @@ -498,7 +510,7 @@ }, "node_modules/@babel/helper-wrap-function": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz", "integrity": "sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==", "license": "MIT", "dependencies": { @@ -512,7 +524,7 @@ }, "node_modules/@babel/helpers": { "version": "7.29.2", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz", + "resolved": "https://registry.npmmirror.com/@babel/helpers/-/helpers-7.29.2.tgz", "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==", "license": "MIT", "dependencies": { @@ -525,7 +537,7 @@ }, "node_modules/@babel/parser": { "version": "7.29.2", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "resolved": "https://registry.npmmirror.com/@babel/parser/-/parser-7.29.2.tgz", "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", "license": "MIT", "dependencies": { @@ -540,7 +552,7 @@ }, "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz", "integrity": "sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==", "license": "MIT", "dependencies": { @@ -556,7 +568,7 @@ }, "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz", "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==", "license": "MIT", "dependencies": { @@ -571,7 +583,7 @@ }, "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz", "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==", "license": "MIT", "dependencies": { @@ -586,7 +598,7 @@ }, "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz", "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==", "license": "MIT", "dependencies": { @@ -603,7 +615,7 @@ }, "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz", "integrity": "sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==", "license": "MIT", "dependencies": { @@ -619,7 +631,7 @@ }, "node_modules/@babel/plugin-proposal-class-properties": { "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", "integrity": "sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==", "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-class-properties instead.", "license": "MIT", @@ -636,7 +648,7 @@ }, "node_modules/@babel/plugin-proposal-decorators": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.29.0.tgz", "integrity": "sha512-CVBVv3VY/XRMxRYq5dwr2DS7/MvqPm23cOCjbwNnVrfOqcWlnefua1uUs0sjdKOGjvPUG633o07uWzJq4oI6dA==", "license": "MIT", "dependencies": { @@ -653,7 +665,7 @@ }, "node_modules/@babel/plugin-proposal-optional-chaining": { "version": "7.21.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.21.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.21.0.tgz", "integrity": "sha512-p4zeefM72gpmEe2fkUr/OnOXpWEf8nAgk7ZYVqqfFiyIG7oFfVZcCrU64hWn5xp4tQ9LkV4bTIa5rD0KANpKNA==", "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-optional-chaining instead.", "license": "MIT", @@ -671,7 +683,7 @@ }, "node_modules/@babel/plugin-proposal-private-property-in-object": { "version": "7.21.0-placeholder-for-preset-env.2", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", "license": "MIT", "engines": { @@ -683,7 +695,7 @@ }, "node_modules/@babel/plugin-syntax-decorators": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.28.6.tgz", "integrity": "sha512-71EYI0ONURHJBL4rSFXnITXqXrrY8q4P0q006DPfN+Rk+ASM+++IBXem/ruokgBZR8YNEWZ8R6B+rCb8VcUTqA==", "license": "MIT", "dependencies": { @@ -698,7 +710,7 @@ }, "node_modules/@babel/plugin-syntax-export-default-from": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-export-default-from/-/plugin-syntax-export-default-from-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-export-default-from/-/plugin-syntax-export-default-from-7.28.6.tgz", "integrity": "sha512-Svlx1fjJFnNz0LZeUaybRukSxZI3KkpApUmIRzEdXC5k8ErTOz0OD0kNrICi5Vc3GlpP5ZCeRyRO+mfWTSz+iQ==", "license": "MIT", "dependencies": { @@ -713,7 +725,7 @@ }, "node_modules/@babel/plugin-syntax-import-assertions": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz", "integrity": "sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==", "license": "MIT", "dependencies": { @@ -728,7 +740,7 @@ }, "node_modules/@babel/plugin-syntax-import-attributes": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz", "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==", "license": "MIT", "dependencies": { @@ -743,7 +755,7 @@ }, "node_modules/@babel/plugin-syntax-json-strings": { "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", "license": "MIT", "dependencies": { @@ -755,7 +767,7 @@ }, "node_modules/@babel/plugin-syntax-jsx": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz", "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==", "license": "MIT", "dependencies": { @@ -770,7 +782,7 @@ }, "node_modules/@babel/plugin-syntax-optional-chaining": { "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", "license": "MIT", "dependencies": { @@ -782,7 +794,7 @@ }, "node_modules/@babel/plugin-syntax-top-level-await": { "version": "7.14.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", "dev": true, "license": "MIT", @@ -798,7 +810,7 @@ }, "node_modules/@babel/plugin-syntax-typescript": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz", "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==", "license": "MIT", "dependencies": { @@ -813,7 +825,7 @@ }, "node_modules/@babel/plugin-syntax-unicode-sets-regex": { "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", "license": "MIT", "dependencies": { @@ -829,7 +841,7 @@ }, "node_modules/@babel/plugin-transform-arrow-functions": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==", "license": "MIT", "dependencies": { @@ -844,7 +856,7 @@ }, "node_modules/@babel/plugin-transform-async-generator-functions": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz", "integrity": "sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==", "license": "MIT", "dependencies": { @@ -861,7 +873,7 @@ }, "node_modules/@babel/plugin-transform-async-to-generator": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz", "integrity": "sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==", "license": "MIT", "dependencies": { @@ -878,7 +890,7 @@ }, "node_modules/@babel/plugin-transform-block-scoped-functions": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz", "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==", "license": "MIT", "dependencies": { @@ -893,7 +905,7 @@ }, "node_modules/@babel/plugin-transform-block-scoping": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz", "integrity": "sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==", "license": "MIT", "dependencies": { @@ -908,7 +920,7 @@ }, "node_modules/@babel/plugin-transform-class-properties": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz", "integrity": "sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==", "license": "MIT", "dependencies": { @@ -924,7 +936,7 @@ }, "node_modules/@babel/plugin-transform-class-static-block": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz", "integrity": "sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==", "license": "MIT", "dependencies": { @@ -940,7 +952,7 @@ }, "node_modules/@babel/plugin-transform-classes": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz", "integrity": "sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==", "license": "MIT", "dependencies": { @@ -960,7 +972,7 @@ }, "node_modules/@babel/plugin-transform-computed-properties": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz", "integrity": "sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==", "license": "MIT", "dependencies": { @@ -976,7 +988,7 @@ }, "node_modules/@babel/plugin-transform-destructuring": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz", "integrity": "sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==", "license": "MIT", "dependencies": { @@ -992,7 +1004,7 @@ }, "node_modules/@babel/plugin-transform-dotall-regex": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz", "integrity": "sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==", "license": "MIT", "dependencies": { @@ -1008,7 +1020,7 @@ }, "node_modules/@babel/plugin-transform-duplicate-keys": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz", "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==", "license": "MIT", "dependencies": { @@ -1023,7 +1035,7 @@ }, "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz", "integrity": "sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==", "license": "MIT", "dependencies": { @@ -1039,7 +1051,7 @@ }, "node_modules/@babel/plugin-transform-dynamic-import": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz", "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==", "license": "MIT", "dependencies": { @@ -1054,7 +1066,7 @@ }, "node_modules/@babel/plugin-transform-explicit-resource-management": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz", "integrity": "sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==", "license": "MIT", "dependencies": { @@ -1070,7 +1082,7 @@ }, "node_modules/@babel/plugin-transform-exponentiation-operator": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz", "integrity": "sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==", "license": "MIT", "dependencies": { @@ -1085,7 +1097,7 @@ }, "node_modules/@babel/plugin-transform-export-namespace-from": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz", "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==", "license": "MIT", "dependencies": { @@ -1100,7 +1112,7 @@ }, "node_modules/@babel/plugin-transform-for-of": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz", "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==", "license": "MIT", "dependencies": { @@ -1116,7 +1128,7 @@ }, "node_modules/@babel/plugin-transform-function-name": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz", "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==", "license": "MIT", "dependencies": { @@ -1133,7 +1145,7 @@ }, "node_modules/@babel/plugin-transform-json-strings": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz", "integrity": "sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==", "license": "MIT", "dependencies": { @@ -1148,7 +1160,7 @@ }, "node_modules/@babel/plugin-transform-literals": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz", "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==", "license": "MIT", "dependencies": { @@ -1163,7 +1175,7 @@ }, "node_modules/@babel/plugin-transform-logical-assignment-operators": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz", "integrity": "sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==", "license": "MIT", "dependencies": { @@ -1178,7 +1190,7 @@ }, "node_modules/@babel/plugin-transform-member-expression-literals": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz", "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==", "license": "MIT", "dependencies": { @@ -1193,7 +1205,7 @@ }, "node_modules/@babel/plugin-transform-modules-amd": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz", "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==", "license": "MIT", "dependencies": { @@ -1209,7 +1221,7 @@ }, "node_modules/@babel/plugin-transform-modules-commonjs": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz", "integrity": "sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==", "license": "MIT", "dependencies": { @@ -1225,7 +1237,7 @@ }, "node_modules/@babel/plugin-transform-modules-systemjs": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz", "integrity": "sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==", "license": "MIT", "dependencies": { @@ -1243,7 +1255,7 @@ }, "node_modules/@babel/plugin-transform-modules-umd": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz", "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==", "license": "MIT", "dependencies": { @@ -1259,7 +1271,7 @@ }, "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz", "integrity": "sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==", "license": "MIT", "dependencies": { @@ -1275,7 +1287,7 @@ }, "node_modules/@babel/plugin-transform-new-target": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz", "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==", "license": "MIT", "dependencies": { @@ -1290,7 +1302,7 @@ }, "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz", "integrity": "sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==", "license": "MIT", "dependencies": { @@ -1305,7 +1317,7 @@ }, "node_modules/@babel/plugin-transform-numeric-separator": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz", "integrity": "sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==", "license": "MIT", "dependencies": { @@ -1320,7 +1332,7 @@ }, "node_modules/@babel/plugin-transform-object-rest-spread": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz", "integrity": "sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==", "license": "MIT", "dependencies": { @@ -1339,7 +1351,7 @@ }, "node_modules/@babel/plugin-transform-object-super": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz", "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==", "license": "MIT", "dependencies": { @@ -1355,7 +1367,7 @@ }, "node_modules/@babel/plugin-transform-optional-catch-binding": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz", "integrity": "sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==", "license": "MIT", "dependencies": { @@ -1370,7 +1382,7 @@ }, "node_modules/@babel/plugin-transform-optional-chaining": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz", "integrity": "sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==", "license": "MIT", "dependencies": { @@ -1386,7 +1398,7 @@ }, "node_modules/@babel/plugin-transform-parameters": { "version": "7.27.7", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz", "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==", "license": "MIT", "dependencies": { @@ -1401,7 +1413,7 @@ }, "node_modules/@babel/plugin-transform-private-methods": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz", "integrity": "sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==", "license": "MIT", "dependencies": { @@ -1417,7 +1429,7 @@ }, "node_modules/@babel/plugin-transform-private-property-in-object": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz", "integrity": "sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==", "license": "MIT", "dependencies": { @@ -1434,7 +1446,7 @@ }, "node_modules/@babel/plugin-transform-property-literals": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz", "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==", "license": "MIT", "dependencies": { @@ -1449,7 +1461,7 @@ }, "node_modules/@babel/plugin-transform-react-display-name": { "version": "7.28.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz", "integrity": "sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==", "license": "MIT", "dependencies": { @@ -1464,7 +1476,7 @@ }, "node_modules/@babel/plugin-transform-react-jsx": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz", "integrity": "sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==", "license": "MIT", "dependencies": { @@ -1483,7 +1495,7 @@ }, "node_modules/@babel/plugin-transform-react-jsx-development": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz", "integrity": "sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==", "license": "MIT", "dependencies": { @@ -1498,7 +1510,7 @@ }, "node_modules/@babel/plugin-transform-react-pure-annotations": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz", "integrity": "sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==", "license": "MIT", "dependencies": { @@ -1514,7 +1526,7 @@ }, "node_modules/@babel/plugin-transform-regenerator": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz", "integrity": "sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==", "license": "MIT", "dependencies": { @@ -1529,7 +1541,7 @@ }, "node_modules/@babel/plugin-transform-regexp-modifiers": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz", "integrity": "sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==", "license": "MIT", "dependencies": { @@ -1545,7 +1557,7 @@ }, "node_modules/@babel/plugin-transform-reserved-words": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz", "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==", "license": "MIT", "dependencies": { @@ -1560,7 +1572,7 @@ }, "node_modules/@babel/plugin-transform-shorthand-properties": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz", "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==", "license": "MIT", "dependencies": { @@ -1575,7 +1587,7 @@ }, "node_modules/@babel/plugin-transform-spread": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz", "integrity": "sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==", "license": "MIT", "dependencies": { @@ -1591,7 +1603,7 @@ }, "node_modules/@babel/plugin-transform-sticky-regex": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz", "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==", "license": "MIT", "dependencies": { @@ -1606,7 +1618,7 @@ }, "node_modules/@babel/plugin-transform-template-literals": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz", "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==", "license": "MIT", "dependencies": { @@ -1621,7 +1633,7 @@ }, "node_modules/@babel/plugin-transform-typeof-symbol": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz", "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==", "license": "MIT", "dependencies": { @@ -1636,7 +1648,7 @@ }, "node_modules/@babel/plugin-transform-typescript": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz", "integrity": "sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==", "license": "MIT", "dependencies": { @@ -1655,7 +1667,7 @@ }, "node_modules/@babel/plugin-transform-unicode-escapes": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz", "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==", "license": "MIT", "dependencies": { @@ -1670,7 +1682,7 @@ }, "node_modules/@babel/plugin-transform-unicode-property-regex": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz", "integrity": "sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==", "license": "MIT", "dependencies": { @@ -1686,7 +1698,7 @@ }, "node_modules/@babel/plugin-transform-unicode-regex": { "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz", "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==", "license": "MIT", "dependencies": { @@ -1702,7 +1714,7 @@ }, "node_modules/@babel/plugin-transform-unicode-sets-regex": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz", "integrity": "sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==", "license": "MIT", "dependencies": { @@ -1718,7 +1730,7 @@ }, "node_modules/@babel/preset-env": { "version": "7.29.2", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.2.tgz", + "resolved": "https://registry.npmmirror.com/@babel/preset-env/-/preset-env-7.29.2.tgz", "integrity": "sha512-DYD23veRYGvBFhcTY1iUvJnDNpuqNd/BzBwCvzOTKUnJjKg5kpUBh3/u9585Agdkgj+QuygG7jLfOPWMa2KVNw==", "license": "MIT", "dependencies": { @@ -1802,7 +1814,7 @@ }, "node_modules/@babel/preset-env/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -1811,7 +1823,7 @@ }, "node_modules/@babel/preset-modules": { "version": "0.1.6-no-external-plugins", - "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "resolved": "https://registry.npmmirror.com/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", "license": "MIT", "dependencies": { @@ -1825,7 +1837,7 @@ }, "node_modules/@babel/preset-react": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/preset-react/-/preset-react-7.28.5.tgz", "integrity": "sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==", "license": "MIT", "dependencies": { @@ -1845,7 +1857,7 @@ }, "node_modules/@babel/preset-typescript": { "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz", + "resolved": "https://registry.npmmirror.com/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz", "integrity": "sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==", "license": "MIT", "dependencies": { @@ -1864,7 +1876,7 @@ }, "node_modules/@babel/template": { "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "resolved": "https://registry.npmmirror.com/@babel/template/-/template-7.28.6.tgz", "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", "license": "MIT", "dependencies": { @@ -1878,7 +1890,7 @@ }, "node_modules/@babel/traverse": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/traverse/-/traverse-7.29.0.tgz", "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", "license": "MIT", "dependencies": { @@ -1896,7 +1908,7 @@ }, "node_modules/@babel/types": { "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/types/-/types-7.29.0.tgz", "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", "license": "MIT", "dependencies": { @@ -1909,7 +1921,7 @@ }, "node_modules/@colors/colors": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz", + "resolved": "https://registry.npmmirror.com/@colors/colors/-/colors-1.5.0.tgz", "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==", "dev": true, "license": "MIT", @@ -1920,7 +1932,7 @@ }, "node_modules/@es-joy/jsdoccomment": { "version": "0.50.2", - "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.50.2.tgz", + "resolved": "https://registry.npmmirror.com/@es-joy/jsdoccomment/-/jsdoccomment-0.50.2.tgz", "integrity": "sha512-YAdE/IJSpwbOTiaURNCKECdAwqrJuFiZhylmesBcIRawtYKnBR2wxPhoIewMg+Yu+QuYvHfJNReWpoxGBKOChA==", "dev": true, "license": "MIT", @@ -1936,9 +1948,9 @@ } }, "node_modules/@es-joy/jsdoccomment/node_modules/@typescript-eslint/types": { - "version": "8.58.1", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.58.1.tgz", - "integrity": "sha512-io/dV5Aw5ezwzfPBBWLoT+5QfVtP8O7q4Kftjn5azJ88bYyp/ZMCsyW1lpKK46EXJcaYMZ1JtYj+s/7TdzmQMw==", + "version": "8.58.0", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/types/-/types-8.58.0.tgz", + "integrity": "sha512-O9CjxypDT89fbHxRfETNoAnHj/i6IpRK0CvbVN3qibxlLdo5p5hcLmUuCCrHMpxiWSwKyI8mCP7qRNYuOJ0Uww==", "dev": true, "license": "MIT", "engines": { @@ -1949,74 +1961,10 @@ "url": "https://opencollective.com/typescript-eslint" } }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz", - "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==", - "cpu": [ - "ppc64" - ], - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz", - "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==", - "cpu": [ - "arm" - ], - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz", - "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz", - "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz", - "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==", + "version": "0.27.5", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.27.5.tgz", + "integrity": "sha512-I+Ya/MgC6rr8oRWGRDF3BXDfP8K1BVUggHqN6VI2lUZLdDi1IM1v2cy0e3lCPbP+pVcK3Tv8cgUhHse1kaNZZw==", "cpu": [ "arm64" ], @@ -2029,345 +1977,9 @@ "node": ">=18" } }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz", - "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz", - "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz", - "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz", - "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==", - "cpu": [ - "arm" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz", - "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz", - "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==", - "cpu": [ - "ia32" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz", - "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==", - "cpu": [ - "loong64" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz", - "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==", - "cpu": [ - "mips64el" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz", - "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==", - "cpu": [ - "ppc64" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz", - "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==", - "cpu": [ - "riscv64" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz", - "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==", - "cpu": [ - "s390x" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz", - "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz", - "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz", - "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz", - "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz", - "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz", - "integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz", - "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz", - "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==", - "cpu": [ - "arm64" - ], - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz", - "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==", - "cpu": [ - "ia32" - ], - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz", - "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==", - "cpu": [ - "x64" - ], - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, "node_modules/@eslint-community/eslint-utils": { "version": "4.9.1", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "resolved": "https://registry.npmmirror.com/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", "dev": true, "license": "MIT", @@ -2386,7 +1998,7 @@ }, "node_modules/@eslint-community/regexpp": { "version": "4.12.2", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "resolved": "https://registry.npmmirror.com/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", "dev": true, "license": "MIT", @@ -2396,7 +2008,7 @@ }, "node_modules/@eslint/eslintrc": { "version": "2.1.4", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "resolved": "https://registry.npmmirror.com/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", "dev": true, "license": "MIT", @@ -2420,7 +2032,7 @@ }, "node_modules/@eslint/eslintrc/node_modules/globals": { "version": "13.24.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "resolved": "https://registry.npmmirror.com/globals/-/globals-13.24.0.tgz", "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, "license": "MIT", @@ -2436,7 +2048,7 @@ }, "node_modules/@eslint/eslintrc/node_modules/type-fest": { "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "resolved": "https://registry.npmmirror.com/type-fest/-/type-fest-0.20.2.tgz", "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true, "license": "(MIT OR CC0-1.0)", @@ -2449,7 +2061,7 @@ }, "node_modules/@eslint/js": { "version": "8.57.1", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "resolved": "https://registry.npmmirror.com/@eslint/js/-/js-8.57.1.tgz", "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", "dev": true, "license": "MIT", @@ -2459,7 +2071,7 @@ }, "node_modules/@humanwhocodes/config-array": { "version": "0.13.0", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "resolved": "https://registry.npmmirror.com/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", "deprecated": "Use @eslint/config-array instead", "dev": true, @@ -2475,7 +2087,7 @@ }, "node_modules/@humanwhocodes/module-importer": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", "dev": true, "license": "Apache-2.0", @@ -2489,7 +2101,7 @@ }, "node_modules/@humanwhocodes/object-schema": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", "deprecated": "Use @eslint/object-schema instead", "dev": true, @@ -2497,14 +2109,14 @@ }, "node_modules/@inversifyjs/common": { "version": "1.3.3", - "resolved": "https://registry.npmjs.org/@inversifyjs/common/-/common-1.3.3.tgz", + "resolved": "https://registry.npmmirror.com/@inversifyjs/common/-/common-1.3.3.tgz", "integrity": "sha512-ZH0wrgaJwIo3s9gMCDM2wZoxqrJ6gB97jWXncROfYdqZJv8f3EkqT57faZqN5OTeHWgtziQ6F6g3L8rCvGceCw==", "dev": true, "license": "MIT" }, "node_modules/@inversifyjs/core": { "version": "1.3.4", - "resolved": "https://registry.npmjs.org/@inversifyjs/core/-/core-1.3.4.tgz", + "resolved": "https://registry.npmmirror.com/@inversifyjs/core/-/core-1.3.4.tgz", "integrity": "sha512-gCCmA4BdbHEFwvVZ2elWgHuXZWk6AOu/1frxsS+2fWhjEk2c/IhtypLo5ytSUie1BCiT6i9qnEo4bruBomQsAA==", "dev": true, "license": "MIT", @@ -2515,7 +2127,7 @@ }, "node_modules/@inversifyjs/reflect-metadata-utils": { "version": "0.2.3", - "resolved": "https://registry.npmjs.org/@inversifyjs/reflect-metadata-utils/-/reflect-metadata-utils-0.2.3.tgz", + "resolved": "https://registry.npmmirror.com/@inversifyjs/reflect-metadata-utils/-/reflect-metadata-utils-0.2.3.tgz", "integrity": "sha512-d3D0o9TeSlvaGM2I24wcNw/Aj3rc4OYvHXOKDC09YEph5fMMiKd6fq1VTQd9tOkDNWvVbw+cnt45Wy9P/t5Lvw==", "dev": true, "license": "MIT", @@ -2525,7 +2137,7 @@ }, "node_modules/@javascript-obfuscator/escodegen": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/@javascript-obfuscator/escodegen/-/escodegen-2.3.1.tgz", + "resolved": "https://registry.npmmirror.com/@javascript-obfuscator/escodegen/-/escodegen-2.3.1.tgz", "integrity": "sha512-Z0HEAVwwafOume+6LFXirAVZeuEMKWuPzpFbQhCEU9++BMz0IwEa9bmedJ+rMn/IlXRBID9j3gQ0XYAa6jM10g==", "dev": true, "license": "BSD-2-Clause", @@ -2544,7 +2156,7 @@ }, "node_modules/@javascript-obfuscator/escodegen/node_modules/levn": { "version": "0.3.0", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "resolved": "https://registry.npmmirror.com/levn/-/levn-0.3.0.tgz", "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", "dev": true, "license": "MIT", @@ -2558,7 +2170,7 @@ }, "node_modules/@javascript-obfuscator/escodegen/node_modules/optionator": { "version": "0.8.3", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "resolved": "https://registry.npmmirror.com/optionator/-/optionator-0.8.3.tgz", "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", "dev": true, "license": "MIT", @@ -2576,7 +2188,7 @@ }, "node_modules/@javascript-obfuscator/escodegen/node_modules/prelude-ls": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/prelude-ls/-/prelude-ls-1.1.2.tgz", "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", "dev": true, "engines": { @@ -2585,7 +2197,7 @@ }, "node_modules/@javascript-obfuscator/escodegen/node_modules/type-check": { "version": "0.3.2", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "resolved": "https://registry.npmmirror.com/type-check/-/type-check-0.3.2.tgz", "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", "dev": true, "license": "MIT", @@ -2598,7 +2210,7 @@ }, "node_modules/@javascript-obfuscator/estraverse": { "version": "5.4.0", - "resolved": "https://registry.npmjs.org/@javascript-obfuscator/estraverse/-/estraverse-5.4.0.tgz", + "resolved": "https://registry.npmmirror.com/@javascript-obfuscator/estraverse/-/estraverse-5.4.0.tgz", "integrity": "sha512-CZFX7UZVN9VopGbjTx4UXaXsi9ewoM1buL0kY7j1ftYdSs7p2spv9opxFjHlQ/QGTgh4UqufYqJJ0WKLml7b6w==", "dev": true, "license": "BSD-2-Clause", @@ -2608,7 +2220,7 @@ }, "node_modules/@jridgewell/gen-mapping": { "version": "0.3.13", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", "license": "MIT", "dependencies": { @@ -2618,7 +2230,7 @@ }, "node_modules/@jridgewell/remapping": { "version": "2.3.5", - "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/remapping/-/remapping-2.3.5.tgz", "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", "license": "MIT", "dependencies": { @@ -2628,7 +2240,7 @@ }, "node_modules/@jridgewell/resolve-uri": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "license": "MIT", "engines": { @@ -2637,7 +2249,7 @@ }, "node_modules/@jridgewell/source-map": { "version": "0.3.11", - "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/source-map/-/source-map-0.3.11.tgz", "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==", "dev": true, "license": "MIT", @@ -2648,13 +2260,13 @@ }, "node_modules/@jridgewell/sourcemap-codec": { "version": "1.5.5", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", "license": "MIT" }, "node_modules/@jridgewell/trace-mapping": { "version": "0.3.31", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "resolved": "https://registry.npmmirror.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "license": "MIT", "dependencies": { @@ -2664,7 +2276,7 @@ }, "node_modules/@jscpd/badge-reporter": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@jscpd/badge-reporter/-/badge-reporter-4.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@jscpd/badge-reporter/-/badge-reporter-4.0.4.tgz", "integrity": "sha512-I9b4MmLXPM2vo0SxSUWnNGKcA4PjQlD3GzXvFK60z43cN/EIdLbOq3FVwCL+dg2obUqGXKIzAm7EsDFTg0D+mQ==", "dev": true, "license": "MIT", @@ -2676,7 +2288,7 @@ }, "node_modules/@jscpd/badge-reporter/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -2691,7 +2303,7 @@ }, "node_modules/@jscpd/badge-reporter/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -2704,7 +2316,7 @@ }, "node_modules/@jscpd/badge-reporter/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -2714,7 +2326,7 @@ }, "node_modules/@jscpd/core": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@jscpd/core/-/core-4.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@jscpd/core/-/core-4.0.4.tgz", "integrity": "sha512-QGMT3iXEX1fI6lgjPH+x8eyJwhwr2KkpSF5uBpjC0Z5Xloj0yFTFLtwJT+RhxP/Ob4WYrtx2jvpKB269oIwgMQ==", "dev": true, "license": "MIT", @@ -2724,7 +2336,7 @@ }, "node_modules/@jscpd/finder": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@jscpd/finder/-/finder-4.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@jscpd/finder/-/finder-4.0.4.tgz", "integrity": "sha512-qVUWY7Nzuvfd5OIk+n7/5CM98LmFroLqblRXAI2gDABwZrc7qS+WH2SNr0qoUq0f4OqwM+piiwKvwL/VDNn/Cg==", "dev": true, "license": "MIT", @@ -2743,7 +2355,7 @@ }, "node_modules/@jscpd/finder/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -2758,7 +2370,7 @@ }, "node_modules/@jscpd/finder/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -2771,7 +2383,7 @@ }, "node_modules/@jscpd/finder/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -2781,7 +2393,7 @@ }, "node_modules/@jscpd/html-reporter": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@jscpd/html-reporter/-/html-reporter-4.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@jscpd/html-reporter/-/html-reporter-4.0.4.tgz", "integrity": "sha512-YiepyeYkeH74Kx59PJRdUdonznct0wHPFkf6FLQN+mCBoy6leAWCcOfHtcexnp+UsBFDlItG5nRdKrDSxSH+Kg==", "dev": true, "license": "MIT", @@ -2793,7 +2405,7 @@ }, "node_modules/@jscpd/html-reporter/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -2808,7 +2420,7 @@ }, "node_modules/@jscpd/html-reporter/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -2821,7 +2433,7 @@ }, "node_modules/@jscpd/html-reporter/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -2831,7 +2443,7 @@ }, "node_modules/@jscpd/tokenizer": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@jscpd/tokenizer/-/tokenizer-4.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@jscpd/tokenizer/-/tokenizer-4.0.4.tgz", "integrity": "sha512-xxYYY/qaLah/FlwogEbGIxx9CjDO+G9E6qawcy26WwrflzJb6wsnhjwdneN6Wb0RNCDsqvzY+bzG453jsin4UQ==", "dev": true, "license": "MIT", @@ -2842,13 +2454,13 @@ } }, "node_modules/@jsdoc/salty": { - "version": "0.2.12", - "resolved": "https://registry.npmjs.org/@jsdoc/salty/-/salty-0.2.12.tgz", - "integrity": "sha512-TuB0x50EoAvEX/UEWITd8Mkn3WhiTjSvbTMCLj0BhsQEl5iUzjXdA0bETEVpTk+5TGTLR6QktI9H4hLviVeaAQ==", + "version": "0.2.11", + "resolved": "https://registry.npmmirror.com/@jsdoc/salty/-/salty-0.2.11.tgz", + "integrity": "sha512-luR/TZqgru6gNjBQnRIbzNPOmDG62VIFQO7QyEjc1/zk3VP3yoGfuecwP2uOlAmKz+t6aq9bwsBV3FgiyHTT7Q==", "dev": true, "license": "Apache-2.0", "dependencies": { - "lodash": "^4.18.1" + "lodash": "^4.17.23" }, "engines": { "node": ">=v12.0.0" @@ -2856,7 +2468,7 @@ }, "node_modules/@kwsites/file-exists": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@kwsites/file-exists/-/file-exists-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/@kwsites/file-exists/-/file-exists-1.1.1.tgz", "integrity": "sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw==", "dev": true, "license": "MIT", @@ -2866,14 +2478,14 @@ }, "node_modules/@kwsites/promise-deferred": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@kwsites/promise-deferred/-/promise-deferred-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/@kwsites/promise-deferred/-/promise-deferred-1.1.1.tgz", "integrity": "sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw==", "dev": true, "license": "MIT" }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "license": "MIT", "dependencies": { @@ -2886,7 +2498,7 @@ }, "node_modules/@nodelib/fs.stat": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", "license": "MIT", "engines": { @@ -2895,7 +2507,7 @@ }, "node_modules/@nodelib/fs.walk": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "license": "MIT", "dependencies": { @@ -2908,7 +2520,7 @@ }, "node_modules/@pkgr/core": { "version": "0.2.9", - "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.9.tgz", + "resolved": "https://registry.npmmirror.com/@pkgr/core/-/core-0.2.9.tgz", "integrity": "sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==", "dev": true, "license": "MIT", @@ -2921,38 +2533,21 @@ }, "node_modules/@rtsao/scc": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/@rtsao/scc/-/scc-1.1.0.tgz", "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==", "dev": true, "license": "MIT" }, - "node_modules/@simple-git/args-pathspec": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@simple-git/args-pathspec/-/args-pathspec-1.0.2.tgz", - "integrity": "sha512-nEFVejViHUoL8wU8GTcwqrvqfUG40S5ts6S4fr1u1Ki5CklXlRDYThPVA/qurTmCYFGnaX3XpVUmICLHdvhLaA==", - "dev": true, - "license": "MIT" - }, - "node_modules/@simple-git/argv-parser": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@simple-git/argv-parser/-/argv-parser-1.0.3.tgz", - "integrity": "sha512-NMKv9sJcSN2VvnPT9Ja7eKfGy8Q8mMFLwPTCcuZMtv3+mYcLIZflg31S/tp2XCCyiY7YAx6cgBHQ0fwA2fWHpQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@simple-git/args-pathspec": "^1.0.2" - } - }, "node_modules/@types/escodegen": { "version": "0.0.10", - "resolved": "https://registry.npmjs.org/@types/escodegen/-/escodegen-0.0.10.tgz", + "resolved": "https://registry.npmmirror.com/@types/escodegen/-/escodegen-0.0.10.tgz", "integrity": "sha512-IVvcNLEFbiL17qiGRGzyfx/u9K6lA5w6wcQSIgv2h4JG3ZAFIY1Be9ITTSPuARIxRpzW54s8OvcF6PdonBbDzg==", "dev": true, "license": "MIT" }, "node_modules/@types/eslint": { "version": "9.6.1", - "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz", + "resolved": "https://registry.npmmirror.com/@types/eslint/-/eslint-9.6.1.tgz", "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==", "dev": true, "license": "MIT", @@ -2963,7 +2558,7 @@ }, "node_modules/@types/eslint-scope": { "version": "3.7.7", - "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz", + "resolved": "https://registry.npmmirror.com/@types/eslint-scope/-/eslint-scope-3.7.7.tgz", "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==", "dev": true, "license": "MIT", @@ -2974,14 +2569,14 @@ }, "node_modules/@types/estree": { "version": "1.0.8", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "resolved": "https://registry.npmmirror.com/@types/estree/-/estree-1.0.8.tgz", "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", "dev": true, "license": "MIT" }, "node_modules/@types/fs-extra": { "version": "11.0.4", - "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-11.0.4.tgz", + "resolved": "https://registry.npmmirror.com/@types/fs-extra/-/fs-extra-11.0.4.tgz", "integrity": "sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==", "dev": true, "license": "MIT", @@ -2992,21 +2587,21 @@ }, "node_modules/@types/json-schema": { "version": "7.0.15", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "resolved": "https://registry.npmmirror.com/@types/json-schema/-/json-schema-7.0.15.tgz", "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", "dev": true, "license": "MIT" }, "node_modules/@types/json5": { "version": "0.0.29", - "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "resolved": "https://registry.npmmirror.com/@types/json5/-/json5-0.0.29.tgz", "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", "dev": true, "license": "MIT" }, "node_modules/@types/jsonfile": { "version": "6.1.4", - "resolved": "https://registry.npmjs.org/@types/jsonfile/-/jsonfile-6.1.4.tgz", + "resolved": "https://registry.npmmirror.com/@types/jsonfile/-/jsonfile-6.1.4.tgz", "integrity": "sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ==", "dev": true, "license": "MIT", @@ -3016,21 +2611,21 @@ }, "node_modules/@types/linkify-it": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/@types/linkify-it/-/linkify-it-5.0.0.tgz", "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==", "dev": true, "license": "MIT" }, "node_modules/@types/lodash": { "version": "4.17.24", - "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.24.tgz", + "resolved": "https://registry.npmmirror.com/@types/lodash/-/lodash-4.17.24.tgz", "integrity": "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ==", "dev": true, "license": "MIT" }, "node_modules/@types/markdown-it": { "version": "14.1.2", - "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz", + "resolved": "https://registry.npmmirror.com/@types/markdown-it/-/markdown-it-14.1.2.tgz", "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==", "dev": true, "license": "MIT", @@ -3041,29 +2636,29 @@ }, "node_modules/@types/mdurl": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/@types/mdurl/-/mdurl-2.0.0.tgz", "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==", "dev": true, "license": "MIT" }, "node_modules/@types/minimatch": { "version": "3.0.5", - "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.5.tgz", + "resolved": "https://registry.npmmirror.com/@types/minimatch/-/minimatch-3.0.5.tgz", "integrity": "sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==", "dev": true, "license": "MIT" }, "node_modules/@types/mocha": { "version": "10.0.10", - "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz", + "resolved": "https://registry.npmmirror.com/@types/mocha/-/mocha-10.0.10.tgz", "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==", "dev": true, "license": "MIT" }, "node_modules/@types/node": { - "version": "22.19.17", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.17.tgz", - "integrity": "sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q==", + "version": "22.19.15", + "resolved": "https://registry.npmmirror.com/@types/node/-/node-22.19.15.tgz", + "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==", "dev": true, "license": "MIT", "dependencies": { @@ -3072,28 +2667,28 @@ }, "node_modules/@types/sarif": { "version": "2.1.7", - "resolved": "https://registry.npmjs.org/@types/sarif/-/sarif-2.1.7.tgz", + "resolved": "https://registry.npmmirror.com/@types/sarif/-/sarif-2.1.7.tgz", "integrity": "sha512-kRz0VEkJqWLf1LLVN4pT1cg1Z9wAuvI6L97V3m2f5B76Tg8d413ddvLBPTEHAZJlnn4XSvu0FkZtViCQGVyrXQ==", "dev": true, "license": "MIT" }, "node_modules/@types/semver": { "version": "7.7.1", - "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.1.tgz", + "resolved": "https://registry.npmmirror.com/@types/semver/-/semver-7.7.1.tgz", "integrity": "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==", "dev": true, "license": "MIT" }, "node_modules/@types/validator": { "version": "13.15.10", - "resolved": "https://registry.npmjs.org/@types/validator/-/validator-13.15.10.tgz", + "resolved": "https://registry.npmmirror.com/@types/validator/-/validator-13.15.10.tgz", "integrity": "sha512-T8L6i7wCuyoK8A/ZeLYt1+q0ty3Zb9+qbSSvrIVitzT3YjZqkTZ40IbRsPanlB4h1QB3JVL1SYCdR6ngtFYcuA==", "dev": true, "license": "MIT" }, "node_modules/@typescript-eslint/eslint-plugin": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz", "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==", "dev": true, "license": "MIT", @@ -3128,7 +2723,7 @@ }, "node_modules/@typescript-eslint/parser": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/parser/-/parser-5.62.0.tgz", "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==", "dev": true, "license": "BSD-2-Clause", @@ -3156,7 +2751,7 @@ }, "node_modules/@typescript-eslint/scope-manager": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", "dev": true, "license": "MIT", @@ -3174,7 +2769,7 @@ }, "node_modules/@typescript-eslint/type-utils": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz", "integrity": "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==", "dev": true, "license": "MIT", @@ -3202,7 +2797,7 @@ }, "node_modules/@typescript-eslint/types": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/types/-/types-5.62.0.tgz", "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", "dev": true, "license": "MIT", @@ -3216,7 +2811,7 @@ }, "node_modules/@typescript-eslint/typescript-estree": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz", "integrity": "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==", "dev": true, "license": "BSD-2-Clause", @@ -3244,7 +2839,7 @@ }, "node_modules/@typescript-eslint/utils": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/utils/-/utils-5.62.0.tgz", "integrity": "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==", "dev": true, "license": "MIT", @@ -3271,7 +2866,7 @@ }, "node_modules/@typescript-eslint/visitor-keys": { "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", + "resolved": "https://registry.npmmirror.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", "dev": true, "license": "MIT", @@ -3289,21 +2884,21 @@ }, "node_modules/@ungap/promise-all-settled": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz", "integrity": "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==", "dev": true, "license": "ISC" }, "node_modules/@ungap/structured-clone": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", "dev": true, "license": "ISC" }, "node_modules/@webassemblyjs/ast": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/ast/-/ast-1.14.1.tgz", "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==", "dev": true, "license": "MIT", @@ -3314,28 +2909,28 @@ }, "node_modules/@webassemblyjs/floating-point-hex-parser": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz", "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==", "dev": true, "license": "MIT" }, "node_modules/@webassemblyjs/helper-api-error": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz", "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==", "dev": true, "license": "MIT" }, "node_modules/@webassemblyjs/helper-buffer": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz", "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==", "dev": true, "license": "MIT" }, "node_modules/@webassemblyjs/helper-numbers": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz", "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==", "dev": true, "license": "MIT", @@ -3347,14 +2942,14 @@ }, "node_modules/@webassemblyjs/helper-wasm-bytecode": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz", "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==", "dev": true, "license": "MIT" }, "node_modules/@webassemblyjs/helper-wasm-section": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz", "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==", "dev": true, "license": "MIT", @@ -3367,7 +2962,7 @@ }, "node_modules/@webassemblyjs/ieee754": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz", "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==", "dev": true, "license": "MIT", @@ -3377,7 +2972,7 @@ }, "node_modules/@webassemblyjs/leb128": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/leb128/-/leb128-1.13.2.tgz", "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==", "dev": true, "license": "Apache-2.0", @@ -3387,14 +2982,14 @@ }, "node_modules/@webassemblyjs/utf8": { "version": "1.13.2", - "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/utf8/-/utf8-1.13.2.tgz", "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==", "dev": true, "license": "MIT" }, "node_modules/@webassemblyjs/wasm-edit": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz", "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==", "dev": true, "license": "MIT", @@ -3411,7 +3006,7 @@ }, "node_modules/@webassemblyjs/wasm-gen": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz", "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==", "dev": true, "license": "MIT", @@ -3425,7 +3020,7 @@ }, "node_modules/@webassemblyjs/wasm-opt": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz", "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==", "dev": true, "license": "MIT", @@ -3438,7 +3033,7 @@ }, "node_modules/@webassemblyjs/wasm-parser": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz", "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==", "dev": true, "license": "MIT", @@ -3453,7 +3048,7 @@ }, "node_modules/@webassemblyjs/wast-printer": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz", "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==", "dev": true, "license": "MIT", @@ -3464,21 +3059,21 @@ }, "node_modules/@xtuc/ieee754": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz", "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", "dev": true, "license": "BSD-3-Clause" }, "node_modules/@xtuc/long": { "version": "4.2.2", - "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "resolved": "https://registry.npmmirror.com/@xtuc/long/-/long-4.2.2.tgz", "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", "dev": true, "license": "Apache-2.0" }, "node_modules/acorn": { "version": "8.16.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.16.0.tgz", "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", "dev": true, "license": "MIT", @@ -3491,7 +3086,7 @@ }, "node_modules/acorn-import-phases": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz", "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==", "dev": true, "license": "MIT", @@ -3504,7 +3099,7 @@ }, "node_modules/acorn-jsx": { "version": "5.3.2", - "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "resolved": "https://registry.npmmirror.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz", "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", "dev": true, "license": "MIT", @@ -3514,7 +3109,7 @@ }, "node_modules/agent-base": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "resolved": "https://registry.npmmirror.com/agent-base/-/agent-base-6.0.2.tgz", "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", "dev": true, "license": "MIT", @@ -3527,7 +3122,7 @@ }, "node_modules/ajv": { "version": "6.14.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "resolved": "https://registry.npmmirror.com/ajv/-/ajv-6.14.0.tgz", "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", "dev": true, "license": "MIT", @@ -3544,7 +3139,7 @@ }, "node_modules/ajv-formats": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/ajv-formats/-/ajv-formats-3.0.1.tgz", "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", "dev": true, "license": "MIT", @@ -3562,7 +3157,7 @@ }, "node_modules/ajv-formats/node_modules/ajv": { "version": "8.18.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz", + "resolved": "https://registry.npmmirror.com/ajv/-/ajv-8.18.0.tgz", "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "dev": true, "license": "MIT", @@ -3579,14 +3174,14 @@ }, "node_modules/ajv-formats/node_modules/json-schema-traverse": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", "dev": true, "license": "MIT" }, "node_modules/amdefine": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/amdefine/-/amdefine-1.0.1.tgz", "integrity": "sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==", "dev": true, "license": "BSD-3-Clause OR MIT", @@ -3596,7 +3191,7 @@ }, "node_modules/ansi-colors": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-colors/-/ansi-colors-1.1.0.tgz", "integrity": "sha512-SFKX67auSNoVR38N3L+nvsPjOE0bybKTYbkf5tRvushrAPQ9V75huw0ZxBkKVeRU9kqH3d6HA4xTckbwZ4ixmA==", "dev": true, "license": "MIT", @@ -3609,7 +3204,7 @@ }, "node_modules/ansi-gray": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-gray/-/ansi-gray-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-gray/-/ansi-gray-0.1.1.tgz", "integrity": "sha512-HrgGIZUl8h2EHuZaU9hTR/cU5nhKxpVE1V6kdGsQ8e4zirElJ5fvtfc8N7Q1oq1aatO275i8pUFUCpNWCAnVWw==", "dev": true, "license": "MIT", @@ -3622,7 +3217,7 @@ }, "node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, "license": "MIT", @@ -3632,7 +3227,7 @@ }, "node_modules/ansi-styles": { "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-3.2.1.tgz", "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "license": "MIT", "dependencies": { @@ -3644,7 +3239,7 @@ }, "node_modules/ansi-wrap": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/ansi-wrap/-/ansi-wrap-0.1.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-wrap/-/ansi-wrap-0.1.0.tgz", "integrity": "sha512-ZyznvL8k/FZeQHr2T6LzcJ/+vBApDnMNZvfVFy3At0knswWd6rJ3/0Hhmpu8oqa6C92npmozs890sX9Dl6q+Qw==", "dev": true, "license": "MIT", @@ -3654,7 +3249,7 @@ }, "node_modules/antlr4": { "version": "4.9.2", - "resolved": "https://registry.npmjs.org/antlr4/-/antlr4-4.9.2.tgz", + "resolved": "https://registry.npmmirror.com/antlr4/-/antlr4-4.9.2.tgz", "integrity": "sha512-UjMSlenUORL+a+6g4RNZxRh5LcFWybRi2g0ASDBpgXBY6nlavg0BRVAVEQF0dz8jH6SyX3lV7uP5y/krJzc+Hw==", "license": "BSD-3-Clause", "engines": { @@ -3663,13 +3258,13 @@ }, "node_modules/antlr4ts": { "version": "0.5.0-alpha.4", - "resolved": "https://registry.npmjs.org/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz", + "resolved": "https://registry.npmmirror.com/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz", "integrity": "sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==", "license": "BSD-3-Clause" }, "node_modules/anymatch": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/anymatch/-/anymatch-2.0.0.tgz", "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", "dev": true, "license": "ISC", @@ -3680,7 +3275,7 @@ }, "node_modules/anymatch/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -3694,7 +3289,7 @@ }, "node_modules/anymatch/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -3708,7 +3303,7 @@ }, "node_modules/anymatch/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -3722,7 +3317,7 @@ }, "node_modules/anymatch/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -3735,7 +3330,7 @@ }, "node_modules/anymatch/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -3748,7 +3343,7 @@ }, "node_modules/anymatch/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -3758,7 +3353,7 @@ }, "node_modules/anymatch/node_modules/micromatch": { "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-3.1.10.tgz", "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "license": "MIT", @@ -3783,7 +3378,7 @@ }, "node_modules/anymatch/node_modules/normalize-path": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/normalize-path/-/normalize-path-2.1.1.tgz", "integrity": "sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w==", "dev": true, "license": "MIT", @@ -3796,7 +3391,7 @@ }, "node_modules/append-buffer": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/append-buffer/-/append-buffer-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/append-buffer/-/append-buffer-1.0.2.tgz", "integrity": "sha512-WLbYiXzD3y/ATLZFufV/rZvWdZOs+Z/+5v1rBZ463Jn398pa6kcde27cvozYnBoxXblGZTFfoPpsaEw0orU5BA==", "dev": true, "license": "MIT", @@ -3809,14 +3404,14 @@ }, "node_modules/archy": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/archy/-/archy-1.0.0.tgz", "integrity": "sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==", "dev": true, "license": "MIT" }, "node_modules/are-docs-informative": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/are-docs-informative/-/are-docs-informative-0.0.2.tgz", + "resolved": "https://registry.npmmirror.com/are-docs-informative/-/are-docs-informative-0.0.2.tgz", "integrity": "sha512-ixiS0nLNNG5jNQzgZJNoUpBKdo9yTYZMGJ+QgT2jmjR7G7+QHRCc4v6LQ3NgE7EBJq+o0ams3waJwkrlBom8Ig==", "dev": true, "license": "MIT", @@ -3826,14 +3421,14 @@ }, "node_modules/argparse": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", "dev": true, "license": "Python-2.0" }, "node_modules/arr-diff": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/arr-diff/-/arr-diff-4.0.0.tgz", "integrity": "sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==", "dev": true, "license": "MIT", @@ -3843,7 +3438,7 @@ }, "node_modules/arr-filter": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/arr-filter/-/arr-filter-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/arr-filter/-/arr-filter-1.1.2.tgz", "integrity": "sha512-A2BETWCqhsecSvCkWAeVBFLH6sXEUGASuzkpjL3GR1SlL/PWL6M3J8EAAld2Uubmh39tvkJTqC9LeLHCUKmFXA==", "dev": true, "license": "MIT", @@ -3856,7 +3451,7 @@ }, "node_modules/arr-flatten": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/arr-flatten/-/arr-flatten-1.1.0.tgz", "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", "dev": true, "license": "MIT", @@ -3866,7 +3461,7 @@ }, "node_modules/arr-map": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/arr-map/-/arr-map-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/arr-map/-/arr-map-2.0.2.tgz", "integrity": "sha512-tVqVTHt+Q5Xb09qRkbu+DidW1yYzz5izWS2Xm2yFm7qJnmUfz4HPzNxbHkdRJbz2lrqI7S+z17xNYdFcBBO8Hw==", "dev": true, "license": "MIT", @@ -3879,7 +3474,7 @@ }, "node_modules/arr-union": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/arr-union/-/arr-union-3.1.0.tgz", "integrity": "sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q==", "dev": true, "license": "MIT", @@ -3889,7 +3484,7 @@ }, "node_modules/array-buffer-byte-length": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz", "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==", "dev": true, "license": "MIT", @@ -3906,7 +3501,7 @@ }, "node_modules/array-differ": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/array-differ/-/array-differ-3.0.0.tgz", "integrity": "sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==", "dev": true, "license": "MIT", @@ -3916,7 +3511,7 @@ }, "node_modules/array-each": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/array-each/-/array-each-1.0.1.tgz", "integrity": "sha512-zHjL5SZa68hkKHBFBK6DJCTtr9sfTCPCaph/L7tMSLcTFgy+zX7E+6q5UArbtOtMBCtxdICpfTCspRse+ywyXA==", "dev": true, "license": "MIT", @@ -3926,7 +3521,7 @@ }, "node_modules/array-includes": { "version": "3.1.9", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz", + "resolved": "https://registry.npmmirror.com/array-includes/-/array-includes-3.1.9.tgz", "integrity": "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==", "dev": true, "license": "MIT", @@ -3949,7 +3544,7 @@ }, "node_modules/array-initial": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-initial/-/array-initial-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/array-initial/-/array-initial-1.1.0.tgz", "integrity": "sha512-BC4Yl89vneCYfpLrs5JU2aAu9/a+xWbeKhvISg9PT7eWFB9UlRvI+rKEtk6mgxWr3dSkk9gQ8hCrdqt06NXPdw==", "dev": true, "license": "MIT", @@ -3963,7 +3558,7 @@ }, "node_modules/array-initial/node_modules/is-number": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-4.0.0.tgz", "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", "dev": true, "license": "MIT", @@ -3973,7 +3568,7 @@ }, "node_modules/array-last": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/array-last/-/array-last-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/array-last/-/array-last-1.3.0.tgz", "integrity": "sha512-eOCut5rXlI6aCOS7Z7kCplKRKyiFQ6dHFBem4PwlwKeNFk2/XxTrhRh5T9PyaEWGy/NHTZWbY+nsZlNFJu9rYg==", "dev": true, "license": "MIT", @@ -3986,7 +3581,7 @@ }, "node_modules/array-last/node_modules/is-number": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-4.0.0.tgz", "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", "dev": true, "license": "MIT", @@ -3996,7 +3591,7 @@ }, "node_modules/array-slice": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/array-slice/-/array-slice-1.1.0.tgz", "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", "dev": true, "license": "MIT", @@ -4006,7 +3601,7 @@ }, "node_modules/array-sort": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-sort/-/array-sort-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/array-sort/-/array-sort-1.0.0.tgz", "integrity": "sha512-ihLeJkonmdiAsD7vpgN3CRcx2J2S0TiYW+IS/5zHBI7mKUq3ySvBdzzBfD236ubDBQFiiyG3SWCPc+msQ9KoYg==", "dev": true, "license": "MIT", @@ -4021,7 +3616,7 @@ }, "node_modules/array-union": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/array-union/-/array-union-2.1.0.tgz", "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", "dev": true, "license": "MIT", @@ -4031,7 +3626,7 @@ }, "node_modules/array-unique": { "version": "0.3.2", - "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "resolved": "https://registry.npmmirror.com/array-unique/-/array-unique-0.3.2.tgz", "integrity": "sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ==", "dev": true, "license": "MIT", @@ -4041,7 +3636,7 @@ }, "node_modules/array.prototype.findlastindex": { "version": "1.2.6", - "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz", + "resolved": "https://registry.npmmirror.com/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz", "integrity": "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==", "dev": true, "license": "MIT", @@ -4063,7 +3658,7 @@ }, "node_modules/array.prototype.flat": { "version": "1.3.3", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", + "resolved": "https://registry.npmmirror.com/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==", "dev": true, "license": "MIT", @@ -4082,7 +3677,7 @@ }, "node_modules/array.prototype.flatmap": { "version": "1.3.3", - "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", + "resolved": "https://registry.npmmirror.com/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==", "dev": true, "license": "MIT", @@ -4101,7 +3696,7 @@ }, "node_modules/arraybuffer.prototype.slice": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", "dev": true, "license": "MIT", @@ -4123,7 +3718,7 @@ }, "node_modules/arrify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/arrify/-/arrify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/arrify/-/arrify-2.0.1.tgz", "integrity": "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==", "dev": true, "license": "MIT", @@ -4133,14 +3728,14 @@ }, "node_modules/asap": { "version": "2.0.6", - "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "resolved": "https://registry.npmmirror.com/asap/-/asap-2.0.6.tgz", "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==", "dev": true, "license": "MIT" }, "node_modules/assert": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/assert/-/assert-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/assert/-/assert-2.1.0.tgz", "integrity": "sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==", "dev": true, "license": "MIT", @@ -4154,14 +3749,14 @@ }, "node_modules/assert-never": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/assert-never/-/assert-never-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/assert-never/-/assert-never-1.4.0.tgz", "integrity": "sha512-5oJg84os6NMQNl27T9LnZkvvqzvAnHu03ShCnoj6bsJwS7L8AO4lf+C/XjK/nvzEqQB744moC6V128RucQd1jA==", "dev": true, "license": "MIT" }, "node_modules/assertion-error": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/assertion-error/-/assertion-error-1.1.0.tgz", "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", "dev": true, "license": "MIT", @@ -4171,7 +3766,7 @@ }, "node_modules/assign-symbols": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/assign-symbols/-/assign-symbols-1.0.0.tgz", "integrity": "sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==", "dev": true, "license": "MIT", @@ -4181,14 +3776,14 @@ }, "node_modules/async": { "version": "3.2.6", - "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "resolved": "https://registry.npmmirror.com/async/-/async-3.2.6.tgz", "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", "dev": true, "license": "MIT" }, "node_modules/async-done": { "version": "1.3.2", - "resolved": "https://registry.npmjs.org/async-done/-/async-done-1.3.2.tgz", + "resolved": "https://registry.npmmirror.com/async-done/-/async-done-1.3.2.tgz", "integrity": "sha512-uYkTP8dw2og1tu1nmza1n1CMW0qb8gWWlwqMmLb7MhBVs4BXrFziT6HXUd+/RlRA/i4H9AkofYloUbs1fwMqlw==", "dev": true, "license": "MIT", @@ -4204,7 +3799,7 @@ }, "node_modules/async-each": { "version": "1.0.6", - "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.6.tgz", + "resolved": "https://registry.npmmirror.com/async-each/-/async-each-1.0.6.tgz", "integrity": "sha512-c646jH1avxr+aVpndVMeAfYw7wAa6idufrlN3LPA4PmKS0QEGp6PIC9nwz0WQkkvBGAMEki3pFdtxaF39J9vvg==", "dev": true, "funding": [ @@ -4217,7 +3812,7 @@ }, "node_modules/async-function": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/async-function/-/async-function-1.0.0.tgz", "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==", "dev": true, "license": "MIT", @@ -4227,7 +3822,7 @@ }, "node_modules/async-settle": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/async-settle/-/async-settle-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/async-settle/-/async-settle-1.0.0.tgz", "integrity": "sha512-VPXfB4Vk49z1LHHodrEQ6Xf7W4gg1w0dAPROHngx7qgDjqmIQ+fXmwgGXTW/ITLai0YLSvWepJOP9EVpMnEAcw==", "dev": true, "license": "MIT", @@ -4240,7 +3835,7 @@ }, "node_modules/at-least-node": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/at-least-node/-/at-least-node-1.0.0.tgz", "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", "dev": true, "license": "ISC", @@ -4250,7 +3845,7 @@ }, "node_modules/atob": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", + "resolved": "https://registry.npmmirror.com/atob/-/atob-2.1.2.tgz", "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", "dev": true, "license": "(MIT OR Apache-2.0)", @@ -4263,7 +3858,7 @@ }, "node_modules/atomically": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/atomically/-/atomically-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/atomically/-/atomically-2.1.1.tgz", "integrity": "sha512-P4w9o2dqARji6P7MHprklbfiArZAWvo07yW7qs3pdljb3BWr12FIB7W+p0zJiuiVsUpRO0iZn1kFFcpPegg0tQ==", "dev": true, "license": "MIT", @@ -4274,7 +3869,7 @@ }, "node_modules/available-typed-arrays": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "resolved": "https://registry.npmmirror.com/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", "dev": true, "license": "MIT", @@ -4290,7 +3885,7 @@ }, "node_modules/babel-code-frame": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz", "integrity": "sha512-XqYMR2dfdGMW+hd0IUZ2PwK+fGeFkOxZJ0wY+JaQAHzt1Zx8LcvpiZD2NiGkEG8qx0CfkAOr5xt76d1e8vG90g==", "dev": true, "license": "MIT", @@ -4302,7 +3897,7 @@ }, "node_modules/babel-code-frame/node_modules/ansi-regex": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-2.1.1.tgz", "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==", "dev": true, "license": "MIT", @@ -4312,7 +3907,7 @@ }, "node_modules/babel-code-frame/node_modules/ansi-styles": { "version": "2.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-2.2.1.tgz", "integrity": "sha512-kmCevFghRiWM7HB5zTPULl4r9bVFSWjz62MhqizDGUrq2NWuNMQyuv4tHHoKJHs69M/MF64lEcHdYIocrdWQYA==", "dev": true, "license": "MIT", @@ -4322,7 +3917,7 @@ }, "node_modules/babel-code-frame/node_modules/chalk": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-1.1.3.tgz", "integrity": "sha512-U3lRVLMSlsCfjqYPbLyVv11M9CPW4I728d6TCKMAOJueEeB9/8o+eSsMnxPJD+Q+K909sdESg7C+tIkoH6on1A==", "dev": true, "license": "MIT", @@ -4339,14 +3934,14 @@ }, "node_modules/babel-code-frame/node_modules/js-tokens": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/js-tokens/-/js-tokens-3.0.2.tgz", "integrity": "sha512-RjTcuD4xjtthQkaWH7dFlH85L+QaVtSoOyGdZ3g6HFhS9dFNDfLyqgm2NFe2X6cQpeFmt0452FJjFG5UameExg==", "dev": true, "license": "MIT" }, "node_modules/babel-code-frame/node_modules/strip-ansi": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==", "dev": true, "license": "MIT", @@ -4359,7 +3954,7 @@ }, "node_modules/babel-code-frame/node_modules/supports-color": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-2.0.0.tgz", "integrity": "sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==", "dev": true, "license": "MIT", @@ -4369,7 +3964,7 @@ }, "node_modules/babel-helper-call-delegate": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", "integrity": "sha512-RL8n2NiEj+kKztlrVJM9JT1cXzzAdvWFh76xh/H1I4nKwunzE4INBXn8ieCZ+wh4zWszZk7NBS1s/8HR5jDkzQ==", "dev": true, "license": "MIT", @@ -4382,7 +3977,7 @@ }, "node_modules/babel-helper-define-map": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", "integrity": "sha512-bHkmjcC9lM1kmZcVpA5t2om2nzT/xiZpo6TJq7UlZ3wqKfzia4veeXbIhKvJXAMzhhEBd3cR1IElL5AenWEUpA==", "dev": true, "license": "MIT", @@ -4395,7 +3990,7 @@ }, "node_modules/babel-helper-function-name": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", "integrity": "sha512-Oo6+e2iX+o9eVvJ9Y5eKL5iryeRdsIkwRYheCuhYdVHsdEQysbc2z2QkqCLIYnNxkT5Ss3ggrHdXiDI7Dhrn4Q==", "dev": true, "license": "MIT", @@ -4409,7 +4004,7 @@ }, "node_modules/babel-helper-get-function-arity": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", "integrity": "sha512-WfgKFX6swFB1jS2vo+DwivRN4NB8XUdM3ij0Y1gnC21y1tdBoe6xjVnd7NSI6alv+gZXCtJqvrTeMW3fR/c0ng==", "dev": true, "license": "MIT", @@ -4420,7 +4015,7 @@ }, "node_modules/babel-helper-hoist-variables": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", "integrity": "sha512-zAYl3tqerLItvG5cKYw7f1SpvIxS9zi7ohyGHaI9cgDUjAT6YcY9jIEH5CstetP5wHIVSceXwNS7Z5BpJg+rOw==", "dev": true, "license": "MIT", @@ -4431,7 +4026,7 @@ }, "node_modules/babel-helper-optimise-call-expression": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", "integrity": "sha512-Op9IhEaxhbRT8MDXx2iNuMgciu2V8lDvYCNQbDGjdBNCjaMvyLf4wl4A3b8IgndCyQF8TwfgsQ8T3VD8aX1/pA==", "dev": true, "license": "MIT", @@ -4442,7 +4037,7 @@ }, "node_modules/babel-helper-regex": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", "integrity": "sha512-VlPiWmqmGJp0x0oK27Out1D+71nVVCTSdlbhIVoaBAj2lUgrNjBCRR9+llO4lTSb2O4r7PJg+RobRkhBrf6ofg==", "dev": true, "license": "MIT", @@ -4454,7 +4049,7 @@ }, "node_modules/babel-helper-replace-supers": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", "integrity": "sha512-sLI+u7sXJh6+ToqDr57Bv973kCepItDhMou0xCP2YPVmR1jkHSCY+p1no8xErbV1Siz5QE8qKT1WIwybSWlqjw==", "dev": true, "license": "MIT", @@ -4469,7 +4064,7 @@ }, "node_modules/babel-messages": { "version": "6.23.0", - "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-messages/-/babel-messages-6.23.0.tgz", "integrity": "sha512-Bl3ZiA+LjqaMtNYopA9TYE9HP1tQ+E5dLxE0XrAzcIJeK2UqF0/EaqXwBn9esd4UmTfEab+P+UYQ1GnioFIb/w==", "dev": true, "license": "MIT", @@ -4479,7 +4074,7 @@ }, "node_modules/babel-plugin-check-es2015-constants": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", "integrity": "sha512-B1M5KBP29248dViEo1owyY32lk1ZSH2DaNNrXLGt8lyjjHm7pBqAdQ7VKUPR6EEDO323+OvT3MQXbCin8ooWdA==", "dev": true, "license": "MIT", @@ -4489,7 +4084,7 @@ }, "node_modules/babel-plugin-inline-import": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/babel-plugin-inline-import/-/babel-plugin-inline-import-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-inline-import/-/babel-plugin-inline-import-3.0.0.tgz", "integrity": "sha512-thnykl4FMb8QjMjVCuZoUmAM7r2mnTn5qJwrryCvDv6rugbJlTHZMctdjDtEgD0WBAXJOLJSGXN3loooEwx7UQ==", "license": "MIT", "dependencies": { @@ -4498,7 +4093,7 @@ }, "node_modules/babel-plugin-polyfill-corejs2": { "version": "0.4.17", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz", "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==", "license": "MIT", "dependencies": { @@ -4512,7 +4107,7 @@ }, "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "license": "ISC", "bin": { @@ -4521,7 +4116,7 @@ }, "node_modules/babel-plugin-polyfill-corejs3": { "version": "0.14.2", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz", "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==", "license": "MIT", "dependencies": { @@ -4534,7 +4129,7 @@ }, "node_modules/babel-plugin-polyfill-regenerator": { "version": "0.6.8", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz", "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==", "license": "MIT", "dependencies": { @@ -4546,7 +4141,7 @@ }, "node_modules/babel-plugin-transform-es2015-arrow-functions": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", "integrity": "sha512-PCqwwzODXW7JMrzu+yZIaYbPQSKjDTAsNNlK2l5Gg9g4rz2VzLnZsStvp/3c46GfXpwkyufb3NCyG9+50FF1Vg==", "dev": true, "license": "MIT", @@ -4556,7 +4151,7 @@ }, "node_modules/babel-plugin-transform-es2015-block-scoped-functions": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", "integrity": "sha512-2+ujAT2UMBzYFm7tidUsYh+ZoIutxJ3pN9IYrF1/H6dCKtECfhmB8UkHVpyxDwkj0CYbQG35ykoz925TUnBc3A==", "dev": true, "license": "MIT", @@ -4566,7 +4161,7 @@ }, "node_modules/babel-plugin-transform-es2015-block-scoping": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", "integrity": "sha512-YiN6sFAQ5lML8JjCmr7uerS5Yc/EMbgg9G8ZNmk2E3nYX4ckHR01wrkeeMijEf5WHNK5TW0Sl0Uu3pv3EdOJWw==", "dev": true, "license": "MIT", @@ -4580,7 +4175,7 @@ }, "node_modules/babel-plugin-transform-es2015-classes": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", "integrity": "sha512-5Dy7ZbRinGrNtmWpquZKZ3EGY8sDgIVB4CU8Om8q8tnMLrD/m94cKglVcHps0BCTdZ0TJeeAWOq2TK9MIY6cag==", "dev": true, "license": "MIT", @@ -4598,7 +4193,7 @@ }, "node_modules/babel-plugin-transform-es2015-computed-properties": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", "integrity": "sha512-C/uAv4ktFP/Hmh01gMTvYvICrKze0XVX9f2PdIXuriCSvUmV9j+u+BB9f5fJK3+878yMK6dkdcq+Ymr9mrcLzw==", "dev": true, "license": "MIT", @@ -4609,7 +4204,7 @@ }, "node_modules/babel-plugin-transform-es2015-destructuring": { "version": "6.23.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", "integrity": "sha512-aNv/GDAW0j/f4Uy1OEPZn1mqD+Nfy9viFGBfQ5bZyT35YqOiqx7/tXdyfZkJ1sC21NyEsBdfDY6PYmLHF4r5iA==", "dev": true, "license": "MIT", @@ -4619,7 +4214,7 @@ }, "node_modules/babel-plugin-transform-es2015-duplicate-keys": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", "integrity": "sha512-ossocTuPOssfxO2h+Z3/Ea1Vo1wWx31Uqy9vIiJusOP4TbF7tPs9U0sJ9pX9OJPf4lXRGj5+6Gkl/HHKiAP5ug==", "dev": true, "license": "MIT", @@ -4630,7 +4225,7 @@ }, "node_modules/babel-plugin-transform-es2015-for-of": { "version": "6.23.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", "integrity": "sha512-DLuRwoygCoXx+YfxHLkVx5/NpeSbVwfoTeBykpJK7JhYWlL/O8hgAK/reforUnZDlxasOrVPPJVI/guE3dCwkw==", "dev": true, "license": "MIT", @@ -4640,7 +4235,7 @@ }, "node_modules/babel-plugin-transform-es2015-function-name": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", "integrity": "sha512-iFp5KIcorf11iBqu/y/a7DK3MN5di3pNCzto61FqCNnUX4qeBwcV1SLqe10oXNnCaxBUImX3SckX2/o1nsrTcg==", "dev": true, "license": "MIT", @@ -4652,7 +4247,7 @@ }, "node_modules/babel-plugin-transform-es2015-literals": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", "integrity": "sha512-tjFl0cwMPpDYyoqYA9li1/7mGFit39XiNX5DKC/uCNjBctMxyL1/PT/l4rSlbvBG1pOKI88STRdUsWXB3/Q9hQ==", "dev": true, "license": "MIT", @@ -4662,7 +4257,7 @@ }, "node_modules/babel-plugin-transform-es2015-modules-amd": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", "integrity": "sha512-LnIIdGWIKdw7zwckqx+eGjcS8/cl8D74A3BpJbGjKTFFNJSMrjN4bIh22HY1AlkUbeLG6X6OZj56BDvWD+OeFA==", "dev": true, "license": "MIT", @@ -4674,7 +4269,7 @@ }, "node_modules/babel-plugin-transform-es2015-modules-commonjs": { "version": "6.26.2", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz", "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==", "dev": true, "license": "MIT", @@ -4687,7 +4282,7 @@ }, "node_modules/babel-plugin-transform-es2015-modules-systemjs": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", "integrity": "sha512-ONFIPsq8y4bls5PPsAWYXH/21Hqv64TBxdje0FvU3MhIV6QM2j5YS7KvAzg/nTIVLot2D2fmFQrFWCbgHlFEjg==", "dev": true, "license": "MIT", @@ -4699,7 +4294,7 @@ }, "node_modules/babel-plugin-transform-es2015-modules-umd": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", "integrity": "sha512-LpVbiT9CLsuAIp3IG0tfbVo81QIhn6pE8xBJ7XSeCtFlMltuar5VuBV6y6Q45tpui9QWcy5i0vLQfCfrnF7Kiw==", "dev": true, "license": "MIT", @@ -4711,7 +4306,7 @@ }, "node_modules/babel-plugin-transform-es2015-object-super": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", "integrity": "sha512-8G5hpZMecb53vpD3mjs64NhI1au24TAmokQ4B+TBFBjN9cVoGoOvotdrMMRmHvVZUEvqGUPWL514woru1ChZMA==", "dev": true, "license": "MIT", @@ -4722,7 +4317,7 @@ }, "node_modules/babel-plugin-transform-es2015-parameters": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", "integrity": "sha512-8HxlW+BB5HqniD+nLkQ4xSAVq3bR/pcYW9IigY+2y0dI+Y7INFeTbfAQr+63T3E4UDsZGjyb+l9txUnABWxlOQ==", "dev": true, "license": "MIT", @@ -4737,7 +4332,7 @@ }, "node_modules/babel-plugin-transform-es2015-shorthand-properties": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", "integrity": "sha512-mDdocSfUVm1/7Jw/FIRNw9vPrBQNePy6wZJlR8HAUBLybNp1w/6lr6zZ2pjMShee65t/ybR5pT8ulkLzD1xwiw==", "dev": true, "license": "MIT", @@ -4748,7 +4343,7 @@ }, "node_modules/babel-plugin-transform-es2015-spread": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", "integrity": "sha512-3Ghhi26r4l3d0Js933E5+IhHwk0A1yiutj9gwvzmFbVV0sPMYk2lekhOufHBswX7NCoSeF4Xrl3sCIuSIa+zOg==", "dev": true, "license": "MIT", @@ -4758,7 +4353,7 @@ }, "node_modules/babel-plugin-transform-es2015-sticky-regex": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", "integrity": "sha512-CYP359ADryTo3pCsH0oxRo/0yn6UsEZLqYohHmvLQdfS9xkf+MbCzE3/Kolw9OYIY4ZMilH25z/5CbQbwDD+lQ==", "dev": true, "license": "MIT", @@ -4770,7 +4365,7 @@ }, "node_modules/babel-plugin-transform-es2015-template-literals": { "version": "6.22.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", "integrity": "sha512-x8b9W0ngnKzDMHimVtTfn5ryimars1ByTqsfBDwAqLibmuuQY6pgBQi5z1ErIsUOWBdw1bW9FSz5RZUojM4apg==", "dev": true, "license": "MIT", @@ -4780,7 +4375,7 @@ }, "node_modules/babel-plugin-transform-es2015-typeof-symbol": { "version": "6.23.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", "integrity": "sha512-fz6J2Sf4gYN6gWgRZaoFXmq93X+Li/8vf+fb0sGDVtdeWvxC9y5/bTD7bvfWMEq6zetGEHpWjtzRGSugt5kNqw==", "dev": true, "license": "MIT", @@ -4790,7 +4385,7 @@ }, "node_modules/babel-plugin-transform-es2015-unicode-regex": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", "integrity": "sha512-v61Dbbihf5XxnYjtBN04B/JBvsScY37R1cZT5r9permN1cp+b70DY3Ib3fIkgn1DI9U3tGgBJZVD8p/mE/4JbQ==", "dev": true, "license": "MIT", @@ -4802,7 +4397,7 @@ }, "node_modules/babel-plugin-transform-es2015-unicode-regex/node_modules/jsesc": { "version": "0.5.0", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "resolved": "https://registry.npmmirror.com/jsesc/-/jsesc-0.5.0.tgz", "integrity": "sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==", "dev": true, "bin": { @@ -4811,7 +4406,7 @@ }, "node_modules/babel-plugin-transform-es2015-unicode-regex/node_modules/regexpu-core": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/regexpu-core/-/regexpu-core-2.0.0.tgz", "integrity": "sha512-tJ9+S4oKjxY8IZ9jmjnp/mtytu1u3iyIQAfmI51IKWH6bFf7XR1ybtaO6j7INhZKXOTYADk7V5qxaqLkmNxiZQ==", "dev": true, "license": "MIT", @@ -4823,14 +4418,14 @@ }, "node_modules/babel-plugin-transform-es2015-unicode-regex/node_modules/regjsgen": { "version": "0.2.0", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "resolved": "https://registry.npmmirror.com/regjsgen/-/regjsgen-0.2.0.tgz", "integrity": "sha512-x+Y3yA24uF68m5GA+tBjbGYo64xXVJpbToBaWCoSNSc1hdk6dfctaRWrNFTVJZIIhL5GxW8zwjoixbnifnK59g==", "dev": true, "license": "MIT" }, "node_modules/babel-plugin-transform-es2015-unicode-regex/node_modules/regjsparser": { "version": "0.1.5", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "resolved": "https://registry.npmmirror.com/regjsparser/-/regjsparser-0.1.5.tgz", "integrity": "sha512-jlQ9gYLfk2p3V5Ag5fYhA7fv7OHzd1KUH0PRP46xc3TgwjwgROIW572AfYg/X9kaNq/LJnu6oJcFRXlIrGoTRw==", "dev": true, "license": "BSD", @@ -4843,7 +4438,7 @@ }, "node_modules/babel-plugin-transform-regenerator": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", "integrity": "sha512-LS+dBkUGlNR15/5WHKe/8Neawx663qttS6AGqoOUhICc9d1KciBvtrQSuc0PI+CxQ2Q/S1aKuJ+u64GtLdcEZg==", "dev": true, "license": "MIT", @@ -4853,7 +4448,7 @@ }, "node_modules/babel-plugin-transform-strict-mode": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", "integrity": "sha512-j3KtSpjyLSJxNoCDrhwiJad8kw0gJ9REGj8/CqL0HeRyLnvUNYV9zcqluL6QJSXh3nfsLEmSLvwRfGzrgR96Pw==", "dev": true, "license": "MIT", @@ -4864,7 +4459,7 @@ }, "node_modules/babel-preset-es2015": { "version": "6.24.1", - "resolved": "https://registry.npmjs.org/babel-preset-es2015/-/babel-preset-es2015-6.24.1.tgz", + "resolved": "https://registry.npmmirror.com/babel-preset-es2015/-/babel-preset-es2015-6.24.1.tgz", "integrity": "sha512-XfwUqG1Ry6R43m4Wfob+vHbIVBIqTg/TJY4Snku1iIzeH7mUnwHA8Vagmv+ZQbPwhS8HgsdQvy28Py3k5zpoFQ==", "deprecated": "🙌 Thanks for using Babel: we recommend using babel-preset-env now: please read https://babeljs.io/env to update!", "dev": true, @@ -4898,7 +4493,7 @@ }, "node_modules/babel-runtime": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-runtime/-/babel-runtime-6.26.0.tgz", "integrity": "sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g==", "dev": true, "license": "MIT", @@ -4909,7 +4504,7 @@ }, "node_modules/babel-template": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-template/-/babel-template-6.26.0.tgz", "integrity": "sha512-PCOcLFW7/eazGUKIoqH97sO9A2UYMahsn/yRQ7uOk37iutwjq7ODtcTNF+iFDSHNfkctqsLRjLP7URnOx0T1fg==", "dev": true, "license": "MIT", @@ -4923,7 +4518,7 @@ }, "node_modules/babel-traverse": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-traverse/-/babel-traverse-6.26.0.tgz", "integrity": "sha512-iSxeXx7apsjCHe9c7n8VtRXGzI2Bk1rBSOJgCCjfyXb6v1aCqE1KSEpq/8SXuVN8Ka/Rh1WDTF0MDzkvTA4MIA==", "dev": true, "license": "MIT", @@ -4941,7 +4536,7 @@ }, "node_modules/babel-traverse/node_modules/debug": { "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", "dev": true, "license": "MIT", @@ -4951,14 +4546,14 @@ }, "node_modules/babel-traverse/node_modules/ms": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz", "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "dev": true, "license": "MIT" }, "node_modules/babel-types": { "version": "6.26.0", - "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", + "resolved": "https://registry.npmmirror.com/babel-types/-/babel-types-6.26.0.tgz", "integrity": "sha512-zhe3V/26rCWsEZK8kZN+HaQj5yQ1CilTObixFzKW1UWjqG7618Twz6YEsCnjfg5gBcJh02DrpCkS9h98ZqDY+g==", "dev": true, "license": "MIT", @@ -4971,7 +4566,7 @@ }, "node_modules/babel-types/node_modules/to-fast-properties": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz", "integrity": "sha512-lxrWP8ejsq+7E3nNjwYmUBMAgjMTZoTI+sdBOpvNyijeDLa29LUn9QaoXAHv4+Z578hbmHHJKZknzxVtvo77og==", "dev": true, "license": "MIT", @@ -4981,7 +4576,7 @@ }, "node_modules/babel-walk": { "version": "3.0.0-canary-5", - "resolved": "https://registry.npmjs.org/babel-walk/-/babel-walk-3.0.0-canary-5.tgz", + "resolved": "https://registry.npmmirror.com/babel-walk/-/babel-walk-3.0.0-canary-5.tgz", "integrity": "sha512-GAwkz0AihzY5bkwIY5QDR+LvsRQgB/B+1foMPvi0FZPMl5fjD7ICiznUiBdLYMH1QYe6vqu4gWYytZOccLouFw==", "dev": true, "license": "MIT", @@ -4994,7 +4589,7 @@ }, "node_modules/babylon": { "version": "6.18.0", - "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "resolved": "https://registry.npmmirror.com/babylon/-/babylon-6.18.0.tgz", "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==", "dev": true, "license": "MIT", @@ -5004,7 +4599,7 @@ }, "node_modules/bach": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/bach/-/bach-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/bach/-/bach-1.2.0.tgz", "integrity": "sha512-bZOOfCb3gXBXbTFXq3OZtGR88LwGeJvzu6szttaIzymOTS4ZttBNOWSv7aLZja2EMycKtRYV0Oa8SNKH/zkxvg==", "dev": true, "license": "MIT", @@ -5025,21 +4620,21 @@ }, "node_modules/badgen": { "version": "3.2.3", - "resolved": "https://registry.npmjs.org/badgen/-/badgen-3.2.3.tgz", + "resolved": "https://registry.npmmirror.com/badgen/-/badgen-3.2.3.tgz", "integrity": "sha512-svDuwkc63E/z0ky3drpUppB83s/nlgDciH9m+STwwQoWyq7yCgew1qEfJ+9axkKdNq7MskByptWUN9j1PGMwFA==", "dev": true, "license": "MIT" }, "node_modules/balanced-match": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", "dev": true, "license": "MIT" }, "node_modules/base": { "version": "0.11.2", - "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", + "resolved": "https://registry.npmmirror.com/base/-/base-0.11.2.tgz", "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", "dev": true, "license": "MIT", @@ -5058,7 +4653,7 @@ }, "node_modules/base/node_modules/define-property": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-1.0.0.tgz", "integrity": "sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==", "dev": true, "license": "MIT", @@ -5071,7 +4666,7 @@ }, "node_modules/base/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -5085,7 +4680,7 @@ }, "node_modules/base64-js": { "version": "1.5.1", - "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "resolved": "https://registry.npmmirror.com/base64-js/-/base64-js-1.5.1.tgz", "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", "dev": true, "funding": [ @@ -5105,9 +4700,9 @@ "license": "MIT" }, "node_modules/baseline-browser-mapping": { - "version": "2.10.16", - "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.16.tgz", - "integrity": "sha512-Lyf3aK28zpsD1yQMiiHD4RvVb6UdMoo8xzG2XzFIfR9luPzOpcBlAsT/qfB1XWS1bxWT+UtE4WmQgsp297FYOA==", + "version": "2.10.13", + "resolved": "https://registry.npmmirror.com/baseline-browser-mapping/-/baseline-browser-mapping-2.10.13.tgz", + "integrity": "sha512-BL2sTuHOdy0YT1lYieUxTw/QMtPBC3pmlJC6xk8BBYVv6vcw3SGdKemQ+Xsx9ik2F/lYDO9tqsFQH1r9PFuHKw==", "license": "Apache-2.0", "bin": { "baseline-browser-mapping": "dist/cli.cjs" @@ -5118,7 +4713,7 @@ }, "node_modules/binary-extensions": { "version": "1.13.1", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz", + "resolved": "https://registry.npmmirror.com/binary-extensions/-/binary-extensions-1.13.1.tgz", "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==", "dev": true, "license": "MIT", @@ -5128,7 +4723,7 @@ }, "node_modules/bindings": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", + "resolved": "https://registry.npmmirror.com/bindings/-/bindings-1.5.0.tgz", "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", "dev": true, "license": "MIT", @@ -5139,7 +4734,7 @@ }, "node_modules/bl": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", + "resolved": "https://registry.npmmirror.com/bl/-/bl-4.1.0.tgz", "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", "dev": true, "license": "MIT", @@ -5151,7 +4746,7 @@ }, "node_modules/bl/node_modules/readable-stream": { "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "resolved": "https://registry.npmmirror.com/readable-stream/-/readable-stream-3.6.2.tgz", "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "dev": true, "license": "MIT", @@ -5166,7 +4761,7 @@ }, "node_modules/blamer": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/blamer/-/blamer-1.0.7.tgz", + "resolved": "https://registry.npmmirror.com/blamer/-/blamer-1.0.7.tgz", "integrity": "sha512-GbBStl/EVlSWkiJQBZps3H1iARBrC7vt++Jb/TTmCNu/jZ04VW7tSN1nScbFXBUy1AN+jzeL7Zep9sbQxLhXKA==", "dev": true, "license": "MIT", @@ -5180,14 +4775,14 @@ }, "node_modules/bluebird": { "version": "3.7.2", - "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "resolved": "https://registry.npmmirror.com/bluebird/-/bluebird-3.7.2.tgz", "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", "dev": true, "license": "MIT" }, "node_modules/brace-expansion": { "version": "1.1.13", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz", + "resolved": "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-1.1.13.tgz", "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==", "dev": true, "license": "MIT", @@ -5198,7 +4793,7 @@ }, "node_modules/braces": { "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "resolved": "https://registry.npmmirror.com/braces/-/braces-2.3.2.tgz", "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", "dev": true, "license": "MIT", @@ -5220,14 +4815,14 @@ }, "node_modules/browser-stdout": { "version": "1.3.1", - "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "resolved": "https://registry.npmmirror.com/browser-stdout/-/browser-stdout-1.3.1.tgz", "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", "dev": true, "license": "ISC" }, "node_modules/browserslist": { "version": "4.28.2", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz", + "resolved": "https://registry.npmmirror.com/browserslist/-/browserslist-4.28.2.tgz", "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==", "funding": [ { @@ -5260,7 +4855,7 @@ }, "node_modules/buffer": { "version": "5.7.1", - "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", + "resolved": "https://registry.npmmirror.com/buffer/-/buffer-5.7.1.tgz", "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", "dev": true, "funding": [ @@ -5285,7 +4880,7 @@ }, "node_modules/buffer-equal": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/buffer-equal/-/buffer-equal-1.0.1.tgz", "integrity": "sha512-QoV3ptgEaQpvVwbXdSO39iqPQTCxSF7A5U99AxbHYqUdCizL/lH2Z0A2y6nbZucxMEOtNyZfG2s6gsVugGpKkg==", "dev": true, "license": "MIT", @@ -5298,14 +4893,14 @@ }, "node_modules/buffer-from": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/buffer-from/-/buffer-from-1.1.2.tgz", "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", "dev": true, "license": "MIT" }, "node_modules/bytes": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "resolved": "https://registry.npmmirror.com/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", "dev": true, "license": "MIT", @@ -5315,7 +4910,7 @@ }, "node_modules/cache-base": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/cache-base/-/cache-base-1.0.1.tgz", "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", "dev": true, "license": "MIT", @@ -5336,7 +4931,7 @@ }, "node_modules/call-bind": { "version": "1.0.8", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", + "resolved": "https://registry.npmmirror.com/call-bind/-/call-bind-1.0.8.tgz", "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==", "dev": true, "license": "MIT", @@ -5355,7 +4950,7 @@ }, "node_modules/call-bind-apply-helpers": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", "dev": true, "license": "MIT", @@ -5369,7 +4964,7 @@ }, "node_modules/call-bound": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/call-bound/-/call-bound-1.0.4.tgz", "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", "dev": true, "license": "MIT", @@ -5386,7 +4981,7 @@ }, "node_modules/callsites": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/callsites/-/callsites-3.1.0.tgz", "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", "dev": true, "license": "MIT", @@ -5396,7 +4991,7 @@ }, "node_modules/camelcase": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-3.0.0.tgz", "integrity": "sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==", "dev": true, "license": "MIT", @@ -5405,9 +5000,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001787", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001787.tgz", - "integrity": "sha512-mNcrMN9KeI68u7muanUpEejSLghOKlVhRqS/Za2IeyGllJ9I9otGpR9g3nsw7n4W378TE/LyIteA0+/FOZm4Kg==", + "version": "1.0.30001784", + "resolved": "https://registry.npmmirror.com/caniuse-lite/-/caniuse-lite-1.0.30001784.tgz", + "integrity": "sha512-WU346nBTklUV9YfUl60fqRbU5ZqyXlqvo1SgigE1OAXK5bFL8LL9q1K7aap3N739l4BvNqnkm3YrGHiY9sfUQw==", "funding": [ { "type": "opencollective", @@ -5426,7 +5021,7 @@ }, "node_modules/catharsis": { "version": "0.9.0", - "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.9.0.tgz", + "resolved": "https://registry.npmmirror.com/catharsis/-/catharsis-0.9.0.tgz", "integrity": "sha512-prMTQVpcns/tzFgFVkVp6ak6RykZyWb3gu8ckUpd6YkTlacOd3DXGJjIpD4Q6zJirizvaiAjSSHlOsA+6sNh2A==", "dev": true, "license": "MIT", @@ -5439,7 +5034,7 @@ }, "node_modules/chai": { "version": "4.5.0", - "resolved": "https://registry.npmjs.org/chai/-/chai-4.5.0.tgz", + "resolved": "https://registry.npmmirror.com/chai/-/chai-4.5.0.tgz", "integrity": "sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==", "dev": true, "license": "MIT", @@ -5458,7 +5053,7 @@ }, "node_modules/chalk": { "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-2.4.2.tgz", "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", "license": "MIT", "dependencies": { @@ -5472,14 +5067,14 @@ }, "node_modules/chance": { "version": "1.1.13", - "resolved": "https://registry.npmjs.org/chance/-/chance-1.1.13.tgz", + "resolved": "https://registry.npmmirror.com/chance/-/chance-1.1.13.tgz", "integrity": "sha512-V6lQCljcLznE7tUYUM9EOAnnKXbctE6j/rdQkYOHIWbfGQbrzTsAXNW9CdU5XCo4ArXQCj/rb6HgxPlmGJcaUg==", "dev": true, "license": "MIT" }, "node_modules/char-regex": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/char-regex/-/char-regex-1.0.2.tgz", "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", "dev": true, "license": "MIT", @@ -5489,7 +5084,7 @@ }, "node_modules/character-parser": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/character-parser/-/character-parser-2.2.0.tgz", + "resolved": "https://registry.npmmirror.com/character-parser/-/character-parser-2.2.0.tgz", "integrity": "sha512-+UqJQjFEFaTAs3bNsF2j2kEN1baG/zghZbdqoYEDxGZtJo9LBzl1A+m0D4n3qKx8N2FNv8/Xp6yV9mQmBuptaw==", "dev": true, "license": "MIT", @@ -5499,7 +5094,7 @@ }, "node_modules/charenc": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz", + "resolved": "https://registry.npmmirror.com/charenc/-/charenc-0.0.2.tgz", "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==", "dev": true, "license": "BSD-3-Clause", @@ -5509,7 +5104,7 @@ }, "node_modules/check-error": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/check-error/-/check-error-1.0.3.tgz", "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==", "dev": true, "license": "MIT", @@ -5522,7 +5117,7 @@ }, "node_modules/chokidar": { "version": "2.1.8", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz", + "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-2.1.8.tgz", "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==", "dev": true, "license": "MIT", @@ -5545,7 +5140,7 @@ }, "node_modules/chokidar/node_modules/glob-parent": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-3.1.0.tgz", "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", "dev": true, "license": "ISC", @@ -5556,7 +5151,7 @@ }, "node_modules/chokidar/node_modules/glob-parent/node_modules/is-glob": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-3.1.0.tgz", "integrity": "sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==", "dev": true, "license": "MIT", @@ -5569,14 +5164,14 @@ }, "node_modules/chownr": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/chownr/-/chownr-1.1.4.tgz", "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==", "dev": true, "license": "ISC" }, "node_modules/chrome-trace-event": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz", "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==", "dev": true, "license": "MIT", @@ -5586,7 +5181,7 @@ }, "node_modules/class-utils": { "version": "0.3.6", - "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", + "resolved": "https://registry.npmmirror.com/class-utils/-/class-utils-0.3.6.tgz", "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", "dev": true, "license": "MIT", @@ -5602,7 +5197,7 @@ }, "node_modules/class-validator": { "version": "0.14.3", - "resolved": "https://registry.npmjs.org/class-validator/-/class-validator-0.14.3.tgz", + "resolved": "https://registry.npmmirror.com/class-validator/-/class-validator-0.14.3.tgz", "integrity": "sha512-rXXekcjofVN1LTOSw+u4u9WXVEUvNBVjORW154q/IdmYWy1nMbOU9aNtZB0t8m+FJQ9q91jlr2f9CwwUFdFMRA==", "dev": true, "license": "MIT", @@ -5614,7 +5209,7 @@ }, "node_modules/cli-table3": { "version": "0.6.5", - "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.5.tgz", + "resolved": "https://registry.npmmirror.com/cli-table3/-/cli-table3-0.6.5.tgz", "integrity": "sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==", "dev": true, "license": "MIT", @@ -5630,7 +5225,7 @@ }, "node_modules/cliui": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", + "resolved": "https://registry.npmmirror.com/cliui/-/cliui-3.2.0.tgz", "integrity": "sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==", "dev": true, "license": "ISC", @@ -5642,7 +5237,7 @@ }, "node_modules/cliui/node_modules/ansi-regex": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-2.1.1.tgz", "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==", "dev": true, "license": "MIT", @@ -5652,7 +5247,7 @@ }, "node_modules/cliui/node_modules/is-fullwidth-code-point": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", "integrity": "sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==", "dev": true, "license": "MIT", @@ -5665,7 +5260,7 @@ }, "node_modules/cliui/node_modules/string-width": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/string-width/-/string-width-1.0.2.tgz", "integrity": "sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==", "dev": true, "license": "MIT", @@ -5680,7 +5275,7 @@ }, "node_modules/cliui/node_modules/strip-ansi": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==", "dev": true, "license": "MIT", @@ -5693,7 +5288,7 @@ }, "node_modules/clone": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz", + "resolved": "https://registry.npmmirror.com/clone/-/clone-2.1.2.tgz", "integrity": "sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w==", "dev": true, "license": "MIT", @@ -5703,7 +5298,7 @@ }, "node_modules/clone-buffer": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-buffer/-/clone-buffer-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/clone-buffer/-/clone-buffer-1.0.0.tgz", "integrity": "sha512-KLLTJWrvwIP+OPfMn0x2PheDEP20RPUcGXj/ERegTgdmPEZylALQldygiqrPPu8P45uNuPs7ckmReLY6v/iA5g==", "dev": true, "license": "MIT", @@ -5713,14 +5308,14 @@ }, "node_modules/clone-stats": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/clone-stats/-/clone-stats-1.0.0.tgz", "integrity": "sha512-au6ydSpg6nsrigcZ4m8Bc9hxjeW+GJ8xh5G3BJCMt4WXe1H10UNaVOamqQTmrx1kjVuxAHIQSNU6hY4Nsn9/ag==", "dev": true, "license": "MIT" }, "node_modules/cloneable-readable": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/cloneable-readable/-/cloneable-readable-1.1.3.tgz", "integrity": "sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==", "dev": true, "license": "MIT", @@ -5732,7 +5327,7 @@ }, "node_modules/code-point-at": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/code-point-at/-/code-point-at-1.1.0.tgz", "integrity": "sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==", "dev": true, "license": "MIT", @@ -5742,7 +5337,7 @@ }, "node_modules/collection-map": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-map/-/collection-map-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/collection-map/-/collection-map-1.0.0.tgz", "integrity": "sha512-5D2XXSpkOnleOI21TG7p3T0bGAsZ/XknZpKBmGYyluO8pw4zA3K8ZlrBIbC4FXg3m6z/RNFiUFfT2sQK01+UHA==", "dev": true, "license": "MIT", @@ -5757,7 +5352,7 @@ }, "node_modules/collection-visit": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/collection-visit/-/collection-visit-1.0.0.tgz", "integrity": "sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw==", "dev": true, "license": "MIT", @@ -5771,7 +5366,7 @@ }, "node_modules/color-convert": { "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-1.9.3.tgz", "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "license": "MIT", "dependencies": { @@ -5780,13 +5375,13 @@ }, "node_modules/color-name": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.3.tgz", "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", "license": "MIT" }, "node_modules/color-support": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/color-support/-/color-support-1.1.3.tgz", "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", "license": "ISC", "bin": { @@ -5795,7 +5390,7 @@ }, "node_modules/colors": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/colors/-/colors-1.4.0.tgz", "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==", "dev": true, "license": "MIT", @@ -5805,7 +5400,7 @@ }, "node_modules/commander": { "version": "14.0.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz", + "resolved": "https://registry.npmmirror.com/commander/-/commander-14.0.3.tgz", "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==", "license": "MIT", "engines": { @@ -5814,7 +5409,7 @@ }, "node_modules/comment-parser": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.1.tgz", + "resolved": "https://registry.npmmirror.com/comment-parser/-/comment-parser-1.4.1.tgz", "integrity": "sha512-buhp5kePrmda3vhc5B9t7pUQXAb2Tnd0qgpkIhPhkHXxJpiPJ11H0ZEU0oBpJ2QztSbzG/ZxMj/CHsYJqRHmyg==", "dev": true, "license": "MIT", @@ -5824,7 +5419,7 @@ }, "node_modules/component-emitter": { "version": "1.3.1", - "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.1.tgz", + "resolved": "https://registry.npmmirror.com/component-emitter/-/component-emitter-1.3.1.tgz", "integrity": "sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==", "dev": true, "license": "MIT", @@ -5834,14 +5429,14 @@ }, "node_modules/concat-map": { "version": "0.0.1", - "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "resolved": "https://registry.npmmirror.com/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", "dev": true, "license": "MIT" }, "node_modules/concat-stream": { "version": "1.6.2", - "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "resolved": "https://registry.npmmirror.com/concat-stream/-/concat-stream-1.6.2.tgz", "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", "dev": true, "engines": [ @@ -5857,7 +5452,7 @@ }, "node_modules/conf": { "version": "15.0.2", - "resolved": "https://registry.npmjs.org/conf/-/conf-15.0.2.tgz", + "resolved": "https://registry.npmmirror.com/conf/-/conf-15.0.2.tgz", "integrity": "sha512-JBSrutapCafTrddF9dH3lc7+T2tBycGF4uPkI4Js+g4vLLEhG6RZcFi3aJd5zntdf5tQxAejJt8dihkoQ/eSJw==", "dev": true, "license": "MIT", @@ -5881,7 +5476,7 @@ }, "node_modules/conf/node_modules/ajv": { "version": "8.18.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz", + "resolved": "https://registry.npmmirror.com/ajv/-/ajv-8.18.0.tgz", "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "dev": true, "license": "MIT", @@ -5898,21 +5493,21 @@ }, "node_modules/conf/node_modules/json-schema-traverse": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", "dev": true, "license": "MIT" }, "node_modules/confusing-browser-globals": { "version": "1.0.11", - "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", + "resolved": "https://registry.npmmirror.com/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==", "dev": true, "license": "MIT" }, "node_modules/constantinople": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/constantinople/-/constantinople-4.0.1.tgz", + "resolved": "https://registry.npmmirror.com/constantinople/-/constantinople-4.0.1.tgz", "integrity": "sha512-vCrqcSIq4//Gx74TXXCGnHpulY1dskqLTFGDmhrGxzeXL8lF8kvXv6mpNWlJj1uD4DW23D4ljAqbY4RRaaUZIw==", "dev": true, "license": "MIT", @@ -5923,13 +5518,13 @@ }, "node_modules/convert-source-map": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/convert-source-map/-/convert-source-map-2.0.0.tgz", "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", "license": "MIT" }, "node_modules/copy-descriptor": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz", "integrity": "sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw==", "dev": true, "license": "MIT", @@ -5939,7 +5534,7 @@ }, "node_modules/copy-props": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/copy-props/-/copy-props-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/copy-props/-/copy-props-2.0.5.tgz", "integrity": "sha512-XBlx8HSqrT0ObQwmSzM7WE5k8FxTV75h1DX1Z3n6NhQ/UYYAvInWYmG06vFt7hQZArE2fuO62aihiWIVQwh1sw==", "dev": true, "license": "MIT", @@ -5950,7 +5545,7 @@ }, "node_modules/core-js": { "version": "2.6.12", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz", + "resolved": "https://registry.npmmirror.com/core-js/-/core-js-2.6.12.tgz", "integrity": "sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==", "deprecated": "core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.", "dev": true, @@ -5959,7 +5554,7 @@ }, "node_modules/core-js-compat": { "version": "3.49.0", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.49.0.tgz", + "resolved": "https://registry.npmmirror.com/core-js-compat/-/core-js-compat-3.49.0.tgz", "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==", "license": "MIT", "dependencies": { @@ -5972,13 +5567,13 @@ }, "node_modules/core-util-is": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/core-util-is/-/core-util-is-1.0.3.tgz", "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", "license": "MIT" }, "node_modules/cross-spawn": { "version": "7.0.6", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "resolved": "https://registry.npmmirror.com/cross-spawn/-/cross-spawn-7.0.6.tgz", "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dev": true, "license": "MIT", @@ -5993,7 +5588,7 @@ }, "node_modules/crypt": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz", + "resolved": "https://registry.npmmirror.com/crypt/-/crypt-0.0.2.tgz", "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==", "dev": true, "license": "BSD-3-Clause", @@ -6003,7 +5598,7 @@ }, "node_modules/d": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/d/-/d-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/d/-/d-1.0.2.tgz", "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==", "dev": true, "license": "ISC", @@ -6017,7 +5612,7 @@ }, "node_modules/data-view-buffer": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/data-view-buffer/-/data-view-buffer-1.0.2.tgz", "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==", "dev": true, "license": "MIT", @@ -6035,7 +5630,7 @@ }, "node_modules/data-view-byte-length": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz", "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==", "dev": true, "license": "MIT", @@ -6053,7 +5648,7 @@ }, "node_modules/data-view-byte-offset": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==", "dev": true, "license": "MIT", @@ -6071,7 +5666,7 @@ }, "node_modules/date-format": { "version": "4.0.14", - "resolved": "https://registry.npmjs.org/date-format/-/date-format-4.0.14.tgz", + "resolved": "https://registry.npmmirror.com/date-format/-/date-format-4.0.14.tgz", "integrity": "sha512-39BOQLs9ZjKh0/patS9nrT8wc3ioX3/eA/zgbKNopnF2wCqJEoxywwwElATYvRsXdnOxA/OQeQoFZ3rFjVajhg==", "license": "MIT", "engines": { @@ -6080,7 +5675,7 @@ }, "node_modules/debounce-fn": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/debounce-fn/-/debounce-fn-6.0.0.tgz", + "resolved": "https://registry.npmmirror.com/debounce-fn/-/debounce-fn-6.0.0.tgz", "integrity": "sha512-rBMW+F2TXryBwB54Q0d8drNEI+TfoS9JpNTAoVpukbWEhjXQq4rySFYLaqXMFXwdv61Zb2OHtj5bviSoimqxRQ==", "dev": true, "license": "MIT", @@ -6096,7 +5691,7 @@ }, "node_modules/debug": { "version": "4.4.3", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz", "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "license": "MIT", "dependencies": { @@ -6113,7 +5708,7 @@ }, "node_modules/decamelize": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/decamelize/-/decamelize-1.2.0.tgz", "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", "dev": true, "license": "MIT", @@ -6123,7 +5718,7 @@ }, "node_modules/decode-uri-component": { "version": "0.2.2", - "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz", + "resolved": "https://registry.npmmirror.com/decode-uri-component/-/decode-uri-component-0.2.2.tgz", "integrity": "sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==", "dev": true, "license": "MIT", @@ -6133,7 +5728,7 @@ }, "node_modules/decompress-response": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "resolved": "https://registry.npmmirror.com/decompress-response/-/decompress-response-6.0.0.tgz", "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", "dev": true, "license": "MIT", @@ -6149,7 +5744,7 @@ }, "node_modules/deep-eql": { "version": "4.1.4", - "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.4.tgz", + "resolved": "https://registry.npmmirror.com/deep-eql/-/deep-eql-4.1.4.tgz", "integrity": "sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==", "dev": true, "license": "MIT", @@ -6162,7 +5757,7 @@ }, "node_modules/deep-extend": { "version": "0.6.0", - "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "resolved": "https://registry.npmmirror.com/deep-extend/-/deep-extend-0.6.0.tgz", "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", "dev": true, "license": "MIT", @@ -6172,14 +5767,14 @@ }, "node_modules/deep-is": { "version": "0.1.4", - "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "resolved": "https://registry.npmmirror.com/deep-is/-/deep-is-0.1.4.tgz", "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", "dev": true, "license": "MIT" }, "node_modules/default-compare": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/default-compare/-/default-compare-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/default-compare/-/default-compare-1.0.0.tgz", "integrity": "sha512-QWfXlM0EkAbqOCbD/6HjdwT19j7WCkMyiRhWilc4H9/5h/RzTF9gv5LYh1+CmDV5d1rki6KAWLtQale0xt20eQ==", "dev": true, "license": "MIT", @@ -6192,7 +5787,7 @@ }, "node_modules/default-resolution": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/default-resolution/-/default-resolution-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/default-resolution/-/default-resolution-2.0.0.tgz", "integrity": "sha512-2xaP6GiwVwOEbXCGoJ4ufgC76m8cj805jrghScewJC2ZDsb9U0b4BIrba+xt/Uytyd0HvQ6+WymSRTfnYj59GQ==", "dev": true, "license": "MIT", @@ -6202,7 +5797,7 @@ }, "node_modules/define-data-property": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/define-data-property/-/define-data-property-1.1.4.tgz", "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", "dev": true, "license": "MIT", @@ -6220,7 +5815,7 @@ }, "node_modules/define-properties": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/define-properties/-/define-properties-1.2.1.tgz", "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", "dev": true, "license": "MIT", @@ -6238,7 +5833,7 @@ }, "node_modules/define-property": { "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-0.2.5.tgz", "integrity": "sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA==", "dev": true, "license": "MIT", @@ -6251,7 +5846,7 @@ }, "node_modules/detect-file": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/detect-file/-/detect-file-1.0.0.tgz", "integrity": "sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==", "dev": true, "license": "MIT", @@ -6261,7 +5856,7 @@ }, "node_modules/detect-libc": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "resolved": "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", "dev": true, "license": "Apache-2.0", @@ -6271,7 +5866,7 @@ }, "node_modules/diff": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/diff/-/diff-5.0.0.tgz", "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", "dev": true, "license": "BSD-3-Clause", @@ -6281,13 +5876,13 @@ }, "node_modules/diff-match-patch": { "version": "1.0.5", - "resolved": "https://registry.npmjs.org/diff-match-patch/-/diff-match-patch-1.0.5.tgz", + "resolved": "https://registry.npmmirror.com/diff-match-patch/-/diff-match-patch-1.0.5.tgz", "integrity": "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw==", "license": "Apache-2.0" }, "node_modules/dir-glob": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/dir-glob/-/dir-glob-3.0.1.tgz", "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", "dev": true, "license": "MIT", @@ -6300,7 +5895,7 @@ }, "node_modules/doctrine": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/doctrine/-/doctrine-3.0.0.tgz", "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", "dev": true, "license": "Apache-2.0", @@ -6313,14 +5908,14 @@ }, "node_modules/doctypes": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/doctypes/-/doctypes-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/doctypes/-/doctypes-1.1.0.tgz", "integrity": "sha512-LLBi6pEqS6Do3EKQ3J0NqHWV5hhb78Pi8vvESYwyOy2c31ZEZVdtitdzsQsKb7878PEERhzUk0ftqGhG6Mz+pQ==", "dev": true, "license": "MIT" }, "node_modules/dot-prop": { "version": "10.1.0", - "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-10.1.0.tgz", + "resolved": "https://registry.npmmirror.com/dot-prop/-/dot-prop-10.1.0.tgz", "integrity": "sha512-MVUtAugQMOff5RnBy2d9N31iG0lNwg1qAoAOn7pOK5wf94WIaE3My2p3uwTQuvS2AcqchkcR3bHByjaM0mmi7Q==", "dev": true, "license": "MIT", @@ -6336,7 +5931,7 @@ }, "node_modules/dunder-proto": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/dunder-proto/-/dunder-proto-1.0.1.tgz", "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", "dev": true, "license": "MIT", @@ -6351,7 +5946,7 @@ }, "node_modules/duplexify": { "version": "3.7.1", - "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz", + "resolved": "https://registry.npmmirror.com/duplexify/-/duplexify-3.7.1.tgz", "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==", "dev": true, "license": "MIT", @@ -6364,7 +5959,7 @@ }, "node_modules/each-props": { "version": "1.3.2", - "resolved": "https://registry.npmjs.org/each-props/-/each-props-1.3.2.tgz", + "resolved": "https://registry.npmmirror.com/each-props/-/each-props-1.3.2.tgz", "integrity": "sha512-vV0Hem3zAGkJAyU7JSjixeU66rwdynTAa1vofCrSA5fEln+m67Az9CcnkVD776/fsN/UjIWmBDoNRS6t6G9RfA==", "dev": true, "license": "MIT", @@ -6375,7 +5970,7 @@ }, "node_modules/each-props/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -6387,21 +5982,21 @@ } }, "node_modules/electron-to-chromium": { - "version": "1.5.333", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.333.tgz", - "integrity": "sha512-skNh4FsE+IpCJV7xAQGbQ4eyOGvcEctVBAk7a5KPzxC3alES9rLrT+2IsPRPgeQr8LVxdJr8BHQ9481+TOr0xg==", + "version": "1.5.331", + "resolved": "https://registry.npmmirror.com/electron-to-chromium/-/electron-to-chromium-1.5.331.tgz", + "integrity": "sha512-IbxXrsTlD3hRodkLnbxAPP4OuJYdWCeM3IOdT+CpcMoIwIoDfCmRpEtSPfwBXxVkg9xmBeY7Lz2Eo2TDn/HC3Q==", "license": "ISC" }, "node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "resolved": "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true, "license": "MIT" }, "node_modules/end-of-stream": { "version": "1.4.5", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "resolved": "https://registry.npmmirror.com/end-of-stream/-/end-of-stream-1.4.5.tgz", "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", "dev": true, "license": "MIT", @@ -6411,7 +6006,7 @@ }, "node_modules/enhanced-resolve": { "version": "5.20.1", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.20.1.tgz", + "resolved": "https://registry.npmmirror.com/enhanced-resolve/-/enhanced-resolve-5.20.1.tgz", "integrity": "sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA==", "dev": true, "license": "MIT", @@ -6425,7 +6020,7 @@ }, "node_modules/entities": { "version": "4.5.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "resolved": "https://registry.npmmirror.com/entities/-/entities-4.5.0.tgz", "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", "dev": true, "license": "BSD-2-Clause", @@ -6438,7 +6033,7 @@ }, "node_modules/env-paths": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/env-paths/-/env-paths-3.0.0.tgz", "integrity": "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==", "dev": true, "license": "MIT", @@ -6451,7 +6046,7 @@ }, "node_modules/error-ex": { "version": "1.3.4", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz", + "resolved": "https://registry.npmmirror.com/error-ex/-/error-ex-1.3.4.tgz", "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==", "dev": true, "license": "MIT", @@ -6460,9 +6055,9 @@ } }, "node_modules/es-abstract": { - "version": "1.24.2", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz", - "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==", + "version": "1.24.1", + "resolved": "https://registry.npmmirror.com/es-abstract/-/es-abstract-1.24.1.tgz", + "integrity": "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==", "dev": true, "license": "MIT", "dependencies": { @@ -6530,7 +6125,7 @@ }, "node_modules/es-define-property": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/es-define-property/-/es-define-property-1.0.1.tgz", "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", "dev": true, "license": "MIT", @@ -6540,7 +6135,7 @@ }, "node_modules/es-errors": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/es-errors/-/es-errors-1.3.0.tgz", "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", "dev": true, "license": "MIT", @@ -6550,14 +6145,14 @@ }, "node_modules/es-module-lexer": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/es-module-lexer/-/es-module-lexer-2.0.0.tgz", "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==", "dev": true, "license": "MIT" }, "node_modules/es-object-atoms": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz", "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", "dev": true, "license": "MIT", @@ -6570,7 +6165,7 @@ }, "node_modules/es-set-tostringtag": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", "dev": true, "license": "MIT", @@ -6586,7 +6181,7 @@ }, "node_modules/es-shim-unscopables": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz", "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==", "dev": true, "license": "MIT", @@ -6599,7 +6194,7 @@ }, "node_modules/es-to-primitive": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/es-to-primitive/-/es-to-primitive-1.3.0.tgz", "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==", "dev": true, "license": "MIT", @@ -6617,7 +6212,7 @@ }, "node_modules/es5-ext": { "version": "0.10.64", - "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.64.tgz", + "resolved": "https://registry.npmmirror.com/es5-ext/-/es5-ext-0.10.64.tgz", "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==", "dev": true, "hasInstallScript": true, @@ -6634,7 +6229,7 @@ }, "node_modules/es6-iterator": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/es6-iterator/-/es6-iterator-2.0.3.tgz", "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==", "dev": true, "license": "MIT", @@ -6646,7 +6241,7 @@ }, "node_modules/es6-symbol": { "version": "3.1.4", - "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.4.tgz", + "resolved": "https://registry.npmmirror.com/es6-symbol/-/es6-symbol-3.1.4.tgz", "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==", "dev": true, "license": "ISC", @@ -6660,7 +6255,7 @@ }, "node_modules/es6-weak-map": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/es6-weak-map/-/es6-weak-map-2.0.3.tgz", "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==", "dev": true, "license": "ISC", @@ -6672,9 +6267,9 @@ } }, "node_modules/esbuild": { - "version": "0.27.7", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz", - "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==", + "version": "0.27.5", + "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.27.5.tgz", + "integrity": "sha512-zdQoHBjuDqKsvV5OPaWansOwfSQ0Js+Uj9J85TBvj3bFW1JjWTSULMRwdQAc8qMeIScbClxeMK0jlrtB9linhA==", "hasInstallScript": true, "license": "MIT", "bin": { @@ -6684,37 +6279,37 @@ "node": ">=18" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.7", - "@esbuild/android-arm": "0.27.7", - "@esbuild/android-arm64": "0.27.7", - "@esbuild/android-x64": "0.27.7", - "@esbuild/darwin-arm64": "0.27.7", - "@esbuild/darwin-x64": "0.27.7", - "@esbuild/freebsd-arm64": "0.27.7", - "@esbuild/freebsd-x64": "0.27.7", - "@esbuild/linux-arm": "0.27.7", - "@esbuild/linux-arm64": "0.27.7", - "@esbuild/linux-ia32": "0.27.7", - "@esbuild/linux-loong64": "0.27.7", - "@esbuild/linux-mips64el": "0.27.7", - "@esbuild/linux-ppc64": "0.27.7", - "@esbuild/linux-riscv64": "0.27.7", - "@esbuild/linux-s390x": "0.27.7", - "@esbuild/linux-x64": "0.27.7", - "@esbuild/netbsd-arm64": "0.27.7", - "@esbuild/netbsd-x64": "0.27.7", - "@esbuild/openbsd-arm64": "0.27.7", - "@esbuild/openbsd-x64": "0.27.7", - "@esbuild/openharmony-arm64": "0.27.7", - "@esbuild/sunos-x64": "0.27.7", - "@esbuild/win32-arm64": "0.27.7", - "@esbuild/win32-ia32": "0.27.7", - "@esbuild/win32-x64": "0.27.7" + "@esbuild/aix-ppc64": "0.27.5", + "@esbuild/android-arm": "0.27.5", + "@esbuild/android-arm64": "0.27.5", + "@esbuild/android-x64": "0.27.5", + "@esbuild/darwin-arm64": "0.27.5", + "@esbuild/darwin-x64": "0.27.5", + "@esbuild/freebsd-arm64": "0.27.5", + "@esbuild/freebsd-x64": "0.27.5", + "@esbuild/linux-arm": "0.27.5", + "@esbuild/linux-arm64": "0.27.5", + "@esbuild/linux-ia32": "0.27.5", + "@esbuild/linux-loong64": "0.27.5", + "@esbuild/linux-mips64el": "0.27.5", + "@esbuild/linux-ppc64": "0.27.5", + "@esbuild/linux-riscv64": "0.27.5", + "@esbuild/linux-s390x": "0.27.5", + "@esbuild/linux-x64": "0.27.5", + "@esbuild/netbsd-arm64": "0.27.5", + "@esbuild/netbsd-x64": "0.27.5", + "@esbuild/openbsd-arm64": "0.27.5", + "@esbuild/openbsd-x64": "0.27.5", + "@esbuild/openharmony-arm64": "0.27.5", + "@esbuild/sunos-x64": "0.27.5", + "@esbuild/win32-arm64": "0.27.5", + "@esbuild/win32-ia32": "0.27.5", + "@esbuild/win32-x64": "0.27.5" } }, "node_modules/escalade": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "resolved": "https://registry.npmmirror.com/escalade/-/escalade-3.2.0.tgz", "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", "license": "MIT", "engines": { @@ -6723,7 +6318,7 @@ }, "node_modules/escape-string-regexp": { "version": "1.0.5", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", "license": "MIT", "engines": { @@ -6732,7 +6327,7 @@ }, "node_modules/escodegen": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/escodegen/-/escodegen-2.1.0.tgz", "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==", "license": "BSD-2-Clause", "dependencies": { @@ -6753,7 +6348,7 @@ }, "node_modules/eslint": { "version": "8.57.1", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint/-/eslint-8.57.1.tgz", "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", "dev": true, @@ -6810,7 +6405,7 @@ }, "node_modules/eslint-config-airbnb-base": { "version": "15.0.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-15.0.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-config-airbnb-base/-/eslint-config-airbnb-base-15.0.0.tgz", "integrity": "sha512-xaX3z4ZZIcFLvh2oUNvcX5oEofXda7giYmuplVxoOg5A7EXJMrUyqRgR+mhDhPK8LZ4PttFOBvCYDbX3sUoUig==", "dev": true, "license": "MIT", @@ -6830,7 +6425,7 @@ }, "node_modules/eslint-config-airbnb-base/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, "license": "ISC", @@ -6840,7 +6435,7 @@ }, "node_modules/eslint-config-airbnb-typescript": { "version": "17.1.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-typescript/-/eslint-config-airbnb-typescript-17.1.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-config-airbnb-typescript/-/eslint-config-airbnb-typescript-17.1.0.tgz", "integrity": "sha512-GPxI5URre6dDpJ0CtcthSZVBAfI+Uw7un5OYNVxP2EYi3H81Jw701yFP7AU+/vCE7xBtFmjge7kfhhk4+RAiig==", "dev": true, "license": "MIT", @@ -6856,7 +6451,7 @@ }, "node_modules/eslint-config-prettier": { "version": "10.1.8", - "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz", + "resolved": "https://registry.npmmirror.com/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz", "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==", "dev": true, "license": "MIT", @@ -6872,7 +6467,7 @@ }, "node_modules/eslint-import-resolver-node": { "version": "0.3.10", - "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.10.tgz", + "resolved": "https://registry.npmmirror.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.10.tgz", "integrity": "sha512-tRrKqFyCaKict5hOd244sL6EQFNycnMQnBe+j8uqGNXYzsImGbGUU4ibtoaBmv5FLwJwcFJNeg1GeVjQfbMrDQ==", "dev": true, "license": "MIT", @@ -6884,7 +6479,7 @@ }, "node_modules/eslint-import-resolver-node/node_modules/debug": { "version": "3.2.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-3.2.7.tgz", "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", "dev": true, "license": "MIT", @@ -6894,7 +6489,7 @@ }, "node_modules/eslint-import-resolver-node/node_modules/resolve": { "version": "2.0.0-next.6", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.6.tgz", + "resolved": "https://registry.npmmirror.com/resolve/-/resolve-2.0.0-next.6.tgz", "integrity": "sha512-3JmVl5hMGtJ3kMmB3zi3DL25KfkCEyy3Tw7Gmw7z5w8M9WlwoPFnIvwChzu1+cF3iaK3sp18hhPz8ANeimdJfA==", "dev": true, "license": "MIT", @@ -6918,7 +6513,7 @@ }, "node_modules/eslint-module-utils": { "version": "2.12.1", - "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz", "integrity": "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==", "dev": true, "license": "MIT", @@ -6936,7 +6531,7 @@ }, "node_modules/eslint-module-utils/node_modules/debug": { "version": "3.2.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-3.2.7.tgz", "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", "dev": true, "license": "MIT", @@ -6946,7 +6541,7 @@ }, "node_modules/eslint-plugin-filenames": { "version": "1.3.2", - "resolved": "https://registry.npmjs.org/eslint-plugin-filenames/-/eslint-plugin-filenames-1.3.2.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-filenames/-/eslint-plugin-filenames-1.3.2.tgz", "integrity": "sha512-tqxJTiEM5a0JmRCUYQmxw23vtTxrb2+a3Q2mMOPhFxvt7ZQQJmdiuMby9B/vUAuVMghyP7oET+nIf6EO6CBd/w==", "dev": true, "license": "MIT", @@ -6962,7 +6557,7 @@ }, "node_modules/eslint-plugin-import": { "version": "2.32.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz", "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==", "dev": true, "license": "MIT", @@ -6996,7 +6591,7 @@ }, "node_modules/eslint-plugin-import/node_modules/debug": { "version": "3.2.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-3.2.7.tgz", "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", "dev": true, "license": "MIT", @@ -7006,7 +6601,7 @@ }, "node_modules/eslint-plugin-import/node_modules/doctrine": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/doctrine/-/doctrine-2.1.0.tgz", "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", "dev": true, "license": "Apache-2.0", @@ -7019,7 +6614,7 @@ }, "node_modules/eslint-plugin-import/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, "license": "ISC", @@ -7029,7 +6624,7 @@ }, "node_modules/eslint-plugin-jsdoc": { "version": "50.8.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.8.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.8.0.tgz", "integrity": "sha512-UyGb5755LMFWPrZTEqqvTJ3urLz1iqj+bYOHFNag+sw3NvaMWP9K2z+uIn37XfNALmQLQyrBlJ5mkiVPL7ADEg==", "dev": true, "license": "BSD-3-Clause", @@ -7054,7 +6649,7 @@ }, "node_modules/eslint-plugin-jsdoc/node_modules/escape-string-regexp": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, "license": "MIT", @@ -7067,7 +6662,7 @@ }, "node_modules/eslint-plugin-jsdoc/node_modules/eslint-visitor-keys": { "version": "4.2.1", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", "dev": true, "license": "Apache-2.0", @@ -7080,7 +6675,7 @@ }, "node_modules/eslint-plugin-jsdoc/node_modules/espree": { "version": "10.4.0", - "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "resolved": "https://registry.npmmirror.com/espree/-/espree-10.4.0.tgz", "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", "dev": true, "license": "BSD-2-Clause", @@ -7098,7 +6693,7 @@ }, "node_modules/eslint-plugin-prettier": { "version": "5.5.5", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.5.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.5.tgz", "integrity": "sha512-hscXkbqUZ2sPithAuLm5MXL+Wph+U7wHngPBv9OMWwlP8iaflyxpjTYZkmdgB4/vPIhemRlBEoLrH7UC1n7aUw==", "dev": true, "license": "MIT", @@ -7129,7 +6724,7 @@ }, "node_modules/eslint-plugin-sonarjs": { "version": "0.19.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-sonarjs/-/eslint-plugin-sonarjs-0.19.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-sonarjs/-/eslint-plugin-sonarjs-0.19.0.tgz", "integrity": "sha512-6+s5oNk5TFtVlbRxqZN7FIGmjdPCYQKaTzFPmqieCmsU1kBYDzndTeQav0xtQNwZJWu5awWfTGe8Srq9xFOGnw==", "dev": true, "license": "LGPL-3.0", @@ -7142,7 +6737,7 @@ }, "node_modules/eslint-plugin-unused-imports": { "version": "4.4.1", - "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-4.4.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-4.4.1.tgz", "integrity": "sha512-oZGYUz1X3sRMGUB+0cZyK2VcvRX5lm/vB56PgNNcU+7ficUCKm66oZWKUubXWnOuPjQ8PvmXtCViXBMONPe7tQ==", "dev": true, "license": "MIT", @@ -7158,7 +6753,7 @@ }, "node_modules/eslint-scope": { "version": "5.1.1", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint-scope/-/eslint-scope-5.1.1.tgz", "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", "dev": true, "license": "BSD-2-Clause", @@ -7172,7 +6767,7 @@ }, "node_modules/eslint-scope/node_modules/estraverse": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/estraverse/-/estraverse-4.3.0.tgz", "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", "dev": true, "license": "BSD-2-Clause", @@ -7182,7 +6777,7 @@ }, "node_modules/eslint-visitor-keys": { "version": "3.4.3", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "resolved": "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, "license": "Apache-2.0", @@ -7195,7 +6790,7 @@ }, "node_modules/eslint/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -7211,7 +6806,7 @@ }, "node_modules/eslint/node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", @@ -7228,7 +6823,7 @@ }, "node_modules/eslint/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -7241,14 +6836,14 @@ }, "node_modules/eslint/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/eslint/node_modules/escape-string-regexp": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, "license": "MIT", @@ -7261,7 +6856,7 @@ }, "node_modules/eslint/node_modules/eslint-scope": { "version": "7.2.2", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "resolved": "https://registry.npmmirror.com/eslint-scope/-/eslint-scope-7.2.2.tgz", "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", "dev": true, "license": "BSD-2-Clause", @@ -7278,7 +6873,7 @@ }, "node_modules/eslint/node_modules/globals": { "version": "13.24.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "resolved": "https://registry.npmmirror.com/globals/-/globals-13.24.0.tgz", "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, "license": "MIT", @@ -7294,7 +6889,7 @@ }, "node_modules/eslint/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -7304,7 +6899,7 @@ }, "node_modules/eslint/node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "license": "MIT", @@ -7317,7 +6912,7 @@ }, "node_modules/eslint/node_modules/type-fest": { "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "resolved": "https://registry.npmmirror.com/type-fest/-/type-fest-0.20.2.tgz", "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true, "license": "(MIT OR CC0-1.0)", @@ -7330,7 +6925,7 @@ }, "node_modules/esniff": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/esniff/-/esniff-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/esniff/-/esniff-2.0.1.tgz", "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==", "dev": true, "license": "ISC", @@ -7346,7 +6941,7 @@ }, "node_modules/espree": { "version": "9.6.1", - "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "resolved": "https://registry.npmmirror.com/espree/-/espree-9.6.1.tgz", "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", "dev": true, "license": "BSD-2-Clause", @@ -7364,7 +6959,7 @@ }, "node_modules/esprima": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "resolved": "https://registry.npmmirror.com/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", "license": "BSD-2-Clause", "bin": { @@ -7377,7 +6972,7 @@ }, "node_modules/esquery": { "version": "1.7.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "resolved": "https://registry.npmmirror.com/esquery/-/esquery-1.7.0.tgz", "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", "dev": true, "license": "BSD-3-Clause", @@ -7390,7 +6985,7 @@ }, "node_modules/esrecurse": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/esrecurse/-/esrecurse-4.3.0.tgz", "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", "dev": true, "license": "BSD-2-Clause", @@ -7403,7 +6998,7 @@ }, "node_modules/estraverse": { "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "resolved": "https://registry.npmmirror.com/estraverse/-/estraverse-5.3.0.tgz", "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", "license": "BSD-2-Clause", "engines": { @@ -7412,7 +7007,7 @@ }, "node_modules/esutils": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/esutils/-/esutils-2.0.3.tgz", "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "license": "BSD-2-Clause", "engines": { @@ -7421,7 +7016,7 @@ }, "node_modules/event-emitter": { "version": "0.3.5", - "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz", + "resolved": "https://registry.npmmirror.com/event-emitter/-/event-emitter-0.3.5.tgz", "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==", "dev": true, "license": "MIT", @@ -7432,14 +7027,14 @@ }, "node_modules/eventemitter3": { "version": "5.0.4", - "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "resolved": "https://registry.npmmirror.com/eventemitter3/-/eventemitter3-5.0.4.tgz", "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", "dev": true, "license": "MIT" }, "node_modules/events": { "version": "3.3.0", - "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "resolved": "https://registry.npmmirror.com/events/-/events-3.3.0.tgz", "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", "dev": true, "license": "MIT", @@ -7449,7 +7044,7 @@ }, "node_modules/execa": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", + "resolved": "https://registry.npmmirror.com/execa/-/execa-4.1.0.tgz", "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", "dev": true, "license": "MIT", @@ -7473,7 +7068,7 @@ }, "node_modules/expand-brackets": { "version": "2.1.4", - "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", + "resolved": "https://registry.npmmirror.com/expand-brackets/-/expand-brackets-2.1.4.tgz", "integrity": "sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA==", "dev": true, "license": "MIT", @@ -7492,7 +7087,7 @@ }, "node_modules/expand-brackets/node_modules/debug": { "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", "dev": true, "license": "MIT", @@ -7502,14 +7097,14 @@ }, "node_modules/expand-brackets/node_modules/ms": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz", "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "dev": true, "license": "MIT" }, "node_modules/expand-template": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/expand-template/-/expand-template-2.0.3.tgz", "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==", "dev": true, "license": "(MIT OR WTFPL)", @@ -7519,7 +7114,7 @@ }, "node_modules/expand-tilde": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/expand-tilde/-/expand-tilde-2.0.2.tgz", "integrity": "sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==", "dev": true, "license": "MIT", @@ -7532,7 +7127,7 @@ }, "node_modules/ext": { "version": "1.7.0", - "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz", + "resolved": "https://registry.npmmirror.com/ext/-/ext-1.7.0.tgz", "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==", "dev": true, "license": "ISC", @@ -7542,14 +7137,14 @@ }, "node_modules/extend": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend/-/extend-3.0.2.tgz", "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", "dev": true, "license": "MIT" }, "node_modules/extend-shallow": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", "dev": true, "license": "MIT", @@ -7562,7 +7157,7 @@ }, "node_modules/extglob": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/extglob/-/extglob-2.0.4.tgz", "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", "dev": true, "license": "MIT", @@ -7582,7 +7177,7 @@ }, "node_modules/extglob/node_modules/define-property": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-1.0.0.tgz", "integrity": "sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==", "dev": true, "license": "MIT", @@ -7595,7 +7190,7 @@ }, "node_modules/extglob/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -7609,7 +7204,7 @@ }, "node_modules/fancy-log": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/fancy-log/-/fancy-log-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/fancy-log/-/fancy-log-2.0.0.tgz", "integrity": "sha512-9CzxZbACXMUXW13tS0tI8XsGGmxWzO2DmYrGuBJOJ8k8q2K7hwfJA5qHjuPPe8wtsco33YR9wc+Rlr5wYFvhSA==", "license": "MIT", "dependencies": { @@ -7621,21 +7216,21 @@ }, "node_modules/fast-deep-equal": { "version": "3.1.3", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "resolved": "https://registry.npmmirror.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", "dev": true, "license": "MIT" }, "node_modules/fast-diff": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/fast-diff/-/fast-diff-1.3.0.tgz", "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==", "dev": true, "license": "Apache-2.0" }, "node_modules/fast-glob": { "version": "3.3.3", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "resolved": "https://registry.npmmirror.com/fast-glob/-/fast-glob-3.3.3.tgz", "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", "license": "MIT", "dependencies": { @@ -7651,7 +7246,7 @@ }, "node_modules/fast-glob/node_modules/glob-parent": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "license": "ISC", "dependencies": { @@ -7663,21 +7258,21 @@ }, "node_modules/fast-json-stable-stringify": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", "dev": true, "license": "MIT" }, "node_modules/fast-levenshtein": { "version": "2.0.6", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "resolved": "https://registry.npmmirror.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", "dev": true, "license": "MIT" }, "node_modules/fast-uri": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/fast-uri/-/fast-uri-3.1.0.tgz", "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", "dev": true, "funding": [ @@ -7694,7 +7289,7 @@ }, "node_modules/fastq": { "version": "1.20.1", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz", + "resolved": "https://registry.npmmirror.com/fastq/-/fastq-1.20.1.tgz", "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==", "license": "ISC", "dependencies": { @@ -7703,7 +7298,7 @@ }, "node_modules/file-entry-cache": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "resolved": "https://registry.npmmirror.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz", "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", "dev": true, "license": "MIT", @@ -7716,7 +7311,7 @@ }, "node_modules/file-uri-to-path": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", "dev": true, "license": "MIT", @@ -7724,7 +7319,7 @@ }, "node_modules/fill-range": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/fill-range/-/fill-range-4.0.0.tgz", "integrity": "sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ==", "dev": true, "license": "MIT", @@ -7740,7 +7335,7 @@ }, "node_modules/find-up": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, "license": "MIT", @@ -7757,7 +7352,7 @@ }, "node_modules/findup-sync": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/findup-sync/-/findup-sync-3.0.0.tgz", "integrity": "sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==", "dev": true, "license": "MIT", @@ -7773,7 +7368,7 @@ }, "node_modules/findup-sync/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -7787,7 +7382,7 @@ }, "node_modules/findup-sync/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -7801,7 +7396,7 @@ }, "node_modules/findup-sync/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -7815,7 +7410,7 @@ }, "node_modules/findup-sync/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -7828,7 +7423,7 @@ }, "node_modules/findup-sync/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -7841,7 +7436,7 @@ }, "node_modules/findup-sync/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -7851,7 +7446,7 @@ }, "node_modules/findup-sync/node_modules/micromatch": { "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-3.1.10.tgz", "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "license": "MIT", @@ -7876,7 +7471,7 @@ }, "node_modules/fined": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/fined/-/fined-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/fined/-/fined-1.2.0.tgz", "integrity": "sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==", "dev": true, "license": "MIT", @@ -7893,7 +7488,7 @@ }, "node_modules/fined/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -7906,7 +7501,7 @@ }, "node_modules/flagged-respawn": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/flagged-respawn/-/flagged-respawn-1.0.1.tgz", "integrity": "sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==", "dev": true, "license": "MIT", @@ -7916,7 +7511,7 @@ }, "node_modules/flat": { "version": "5.0.2", - "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "resolved": "https://registry.npmmirror.com/flat/-/flat-5.0.2.tgz", "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", "dev": true, "license": "BSD-3-Clause", @@ -7926,7 +7521,7 @@ }, "node_modules/flat-cache": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "resolved": "https://registry.npmmirror.com/flat-cache/-/flat-cache-3.2.0.tgz", "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", "dev": true, "license": "MIT", @@ -7941,13 +7536,13 @@ }, "node_modules/flatted": { "version": "3.4.2", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz", + "resolved": "https://registry.npmmirror.com/flatted/-/flatted-3.4.2.tgz", "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==", "license": "ISC" }, "node_modules/flush-write-stream": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/flush-write-stream/-/flush-write-stream-1.1.1.tgz", "integrity": "sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==", "dev": true, "license": "MIT", @@ -7958,7 +7553,7 @@ }, "node_modules/for-each": { "version": "0.3.5", - "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", + "resolved": "https://registry.npmmirror.com/for-each/-/for-each-0.3.5.tgz", "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", "dev": true, "license": "MIT", @@ -7974,7 +7569,7 @@ }, "node_modules/for-in": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/for-in/-/for-in-1.0.2.tgz", "integrity": "sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==", "dev": true, "license": "MIT", @@ -7984,7 +7579,7 @@ }, "node_modules/for-own": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/for-own/-/for-own-1.0.0.tgz", "integrity": "sha512-0OABksIGrxKK8K4kynWkQ7y1zounQxP+CWnyclVwj81KW3vlLlGUx57DKGcP/LH216GzqnstnPocF16Nxs0Ycg==", "dev": true, "license": "MIT", @@ -7997,7 +7592,7 @@ }, "node_modules/fragment-cache": { "version": "0.2.1", - "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", + "resolved": "https://registry.npmmirror.com/fragment-cache/-/fragment-cache-0.2.1.tgz", "integrity": "sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA==", "dev": true, "license": "MIT", @@ -8010,7 +7605,7 @@ }, "node_modules/from2": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", + "resolved": "https://registry.npmmirror.com/from2/-/from2-2.3.0.tgz", "integrity": "sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==", "dev": true, "license": "MIT", @@ -8021,14 +7616,14 @@ }, "node_modules/fs-constants": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/fs-constants/-/fs-constants-1.0.0.tgz", "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==", "dev": true, "license": "MIT" }, "node_modules/fs-extra": { "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-7.0.1.tgz", "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==", "license": "MIT", "dependencies": { @@ -8042,7 +7637,7 @@ }, "node_modules/fs-extra/node_modules/jsonfile": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-4.0.0.tgz", "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", "license": "MIT", "optionalDependencies": { @@ -8051,7 +7646,7 @@ }, "node_modules/fs-mkdirp-stream": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz", "integrity": "sha512-+vSd9frUnapVC2RZYfL3FCB2p3g4TBhaUmrsWlSudsGdnxIuUvBB2QM1VZeBtc49QFwrp+wQLrDs3+xxDgI5gQ==", "dev": true, "license": "MIT", @@ -8065,14 +7660,14 @@ }, "node_modules/fs.realpath": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/fs.realpath/-/fs.realpath-1.0.0.tgz", "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", "dev": true, "license": "ISC" }, "node_modules/fsevents": { "version": "1.2.13", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz", + "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-1.2.13.tgz", "integrity": "sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==", "deprecated": "Upgrade to fsevents v2 to mitigate potential security issues", "dev": true, @@ -8092,7 +7687,7 @@ }, "node_modules/function-bind": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/function-bind/-/function-bind-1.1.2.tgz", "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", "license": "MIT", "funding": { @@ -8101,7 +7696,7 @@ }, "node_modules/function.prototype.name": { "version": "1.1.8", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz", + "resolved": "https://registry.npmmirror.com/function.prototype.name/-/function.prototype.name-1.1.8.tgz", "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==", "dev": true, "license": "MIT", @@ -8122,7 +7717,7 @@ }, "node_modules/functions-have-names": { "version": "1.2.3", - "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "resolved": "https://registry.npmmirror.com/functions-have-names/-/functions-have-names-1.2.3.tgz", "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", "dev": true, "license": "MIT", @@ -8132,7 +7727,7 @@ }, "node_modules/generator-function": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/generator-function/-/generator-function-2.0.1.tgz", "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==", "dev": true, "license": "MIT", @@ -8142,7 +7737,7 @@ }, "node_modules/gensync": { "version": "1.0.0-beta.2", - "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "resolved": "https://registry.npmmirror.com/gensync/-/gensync-1.0.0-beta.2.tgz", "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", "license": "MIT", "engines": { @@ -8151,14 +7746,14 @@ }, "node_modules/get-caller-file": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-1.0.3.tgz", "integrity": "sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==", "dev": true, "license": "ISC" }, "node_modules/get-func-name": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/get-func-name/-/get-func-name-2.0.2.tgz", "integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==", "dev": true, "license": "MIT", @@ -8168,7 +7763,7 @@ }, "node_modules/get-intrinsic": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz", "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", "dev": true, "license": "MIT", @@ -8193,7 +7788,7 @@ }, "node_modules/get-proto": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/get-proto/-/get-proto-1.0.1.tgz", "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", "dev": true, "license": "MIT", @@ -8207,7 +7802,7 @@ }, "node_modules/get-stream": { "version": "5.2.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "resolved": "https://registry.npmmirror.com/get-stream/-/get-stream-5.2.0.tgz", "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", "dev": true, "license": "MIT", @@ -8223,7 +7818,7 @@ }, "node_modules/get-symbol-description": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/get-symbol-description/-/get-symbol-description-1.1.0.tgz", "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", "dev": true, "license": "MIT", @@ -8241,7 +7836,7 @@ }, "node_modules/get-tsconfig": { "version": "4.13.7", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.7.tgz", + "resolved": "https://registry.npmmirror.com/get-tsconfig/-/get-tsconfig-4.13.7.tgz", "integrity": "sha512-7tN6rFgBlMgpBML5j8typ92BKFi2sFQvIdpAqLA2beia5avZDrMs0FLZiM5etShWq5irVyGcGMEA1jcDaK7A/Q==", "license": "MIT", "dependencies": { @@ -8253,7 +7848,7 @@ }, "node_modules/get-value": { "version": "2.0.6", - "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", + "resolved": "https://registry.npmmirror.com/get-value/-/get-value-2.0.6.tgz", "integrity": "sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==", "dev": true, "license": "MIT", @@ -8263,14 +7858,14 @@ }, "node_modules/github-from-package": { "version": "0.0.0", - "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz", + "resolved": "https://registry.npmmirror.com/github-from-package/-/github-from-package-0.0.0.tgz", "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==", "dev": true, "license": "MIT" }, "node_modules/gitignore-to-glob": { "version": "0.3.0", - "resolved": "https://registry.npmjs.org/gitignore-to-glob/-/gitignore-to-glob-0.3.0.tgz", + "resolved": "https://registry.npmmirror.com/gitignore-to-glob/-/gitignore-to-glob-0.3.0.tgz", "integrity": "sha512-mk74BdnK7lIwDHnotHddx1wsjMOFIThpLY3cPNniJ/2fA/tlLzHnFxIdR+4sLOu5KGgQJdij4kjJ2RoUNnCNMA==", "dev": true, "license": "MIT", @@ -8280,9 +7875,9 @@ }, "node_modules/glob": { "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", + "resolved": "https://registry.npmmirror.com/glob/-/glob-7.1.6.tgz", "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", - "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "deprecated": "Glob versions prior to v9 are no longer supported", "dev": true, "license": "ISC", "dependencies": { @@ -8302,7 +7897,7 @@ }, "node_modules/glob-parent": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-6.0.2.tgz", "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", "dev": true, "license": "ISC", @@ -8315,7 +7910,7 @@ }, "node_modules/glob-stream": { "version": "6.1.0", - "resolved": "https://registry.npmjs.org/glob-stream/-/glob-stream-6.1.0.tgz", + "resolved": "https://registry.npmmirror.com/glob-stream/-/glob-stream-6.1.0.tgz", "integrity": "sha512-uMbLGAP3S2aDOHUDfdoYcdIePUCfysbAd0IAoWVZbeGU/oNQ8asHVSshLDJUPWxfzj8zsCG7/XeHPHTtow0nsw==", "dev": true, "license": "MIT", @@ -8337,7 +7932,7 @@ }, "node_modules/glob-stream/node_modules/glob-parent": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-3.1.0.tgz", "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", "dev": true, "license": "ISC", @@ -8348,7 +7943,7 @@ }, "node_modules/glob-stream/node_modules/is-glob": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-3.1.0.tgz", "integrity": "sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==", "dev": true, "license": "MIT", @@ -8361,14 +7956,14 @@ }, "node_modules/glob-to-regexp": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "resolved": "https://registry.npmmirror.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", "dev": true, "license": "BSD-2-Clause" }, "node_modules/glob-watcher": { "version": "5.0.5", - "resolved": "https://registry.npmjs.org/glob-watcher/-/glob-watcher-5.0.5.tgz", + "resolved": "https://registry.npmmirror.com/glob-watcher/-/glob-watcher-5.0.5.tgz", "integrity": "sha512-zOZgGGEHPklZNjZQaZ9f41i7F2YwE+tS5ZHrDhbBCk3stwahn5vQxnFmBJZHoYdusR6R1bLSXeGUy/BhctwKzw==", "dev": true, "license": "MIT", @@ -8387,7 +7982,7 @@ }, "node_modules/global-modules": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/global-modules/-/global-modules-1.0.0.tgz", "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", "dev": true, "license": "MIT", @@ -8402,7 +7997,7 @@ }, "node_modules/global-prefix": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/global-prefix/-/global-prefix-1.0.2.tgz", "integrity": "sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==", "dev": true, "license": "MIT", @@ -8419,7 +8014,7 @@ }, "node_modules/global-prefix/node_modules/which": { "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "resolved": "https://registry.npmmirror.com/which/-/which-1.3.1.tgz", "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", "dev": true, "license": "ISC", @@ -8432,7 +8027,7 @@ }, "node_modules/globals": { "version": "9.18.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz", + "resolved": "https://registry.npmmirror.com/globals/-/globals-9.18.0.tgz", "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==", "dev": true, "license": "MIT", @@ -8442,7 +8037,7 @@ }, "node_modules/globalthis": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/globalthis/-/globalthis-1.0.4.tgz", "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", "dev": true, "license": "MIT", @@ -8459,7 +8054,7 @@ }, "node_modules/globby": { "version": "11.1.0", - "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "resolved": "https://registry.npmmirror.com/globby/-/globby-11.1.0.tgz", "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", "dev": true, "license": "MIT", @@ -8480,7 +8075,7 @@ }, "node_modules/glogg": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/glogg/-/glogg-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/glogg/-/glogg-1.0.2.tgz", "integrity": "sha512-5mwUoSuBk44Y4EshyiqcH95ZntbDdTQqA3QYSrxmzj28Ai0vXBGMH1ApSANH14j2sIRtqCEyg6PfsuP7ElOEDA==", "dev": true, "license": "MIT", @@ -8493,7 +8088,7 @@ }, "node_modules/gopd": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/gopd/-/gopd-1.2.0.tgz", "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", "dev": true, "license": "MIT", @@ -8506,20 +8101,20 @@ }, "node_modules/graceful-fs": { "version": "4.2.11", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "resolved": "https://registry.npmmirror.com/graceful-fs/-/graceful-fs-4.2.11.tgz", "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", "license": "ISC" }, "node_modules/graphemer": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/graphemer/-/graphemer-1.4.0.tgz", "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", "dev": true, "license": "MIT" }, "node_modules/graphviz": { "version": "0.0.9", - "resolved": "https://registry.npmjs.org/graphviz/-/graphviz-0.0.9.tgz", + "resolved": "https://registry.npmmirror.com/graphviz/-/graphviz-0.0.9.tgz", "integrity": "sha512-SmoY2pOtcikmMCqCSy2NO1YsRfu9OO0wpTlOYW++giGjfX1a6gax/m1Fo8IdUd0/3H15cTOfR1SMKwohj4LKsg==", "license": "GPL-3.0", "dependencies": { @@ -8531,7 +8126,7 @@ }, "node_modules/growl": { "version": "1.10.5", - "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "resolved": "https://registry.npmmirror.com/growl/-/growl-1.10.5.tgz", "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", "dev": true, "license": "MIT", @@ -8541,7 +8136,7 @@ }, "node_modules/gulp": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz", + "resolved": "https://registry.npmmirror.com/gulp/-/gulp-4.0.2.tgz", "integrity": "sha512-dvEs27SCZt2ibF29xYgmnwwCYZxdxhQ/+LFWlbAW8y7jt68L/65402Lz3+CKy0Ov4rOs+NERmDq7YlZaDqUIfA==", "dev": true, "license": "MIT", @@ -8560,7 +8155,7 @@ }, "node_modules/gulp-babel": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/gulp-babel/-/gulp-babel-8.0.0.tgz", + "resolved": "https://registry.npmmirror.com/gulp-babel/-/gulp-babel-8.0.0.tgz", "integrity": "sha512-oomaIqDXxFkg7lbpBou/gnUkX51/Y/M2ZfSjL2hdqXTAlSWZcgZtd2o0cOH0r/eE8LWD0+Q/PsLsr2DKOoqToQ==", "dev": true, "license": "MIT", @@ -8579,7 +8174,7 @@ }, "node_modules/gulp-cli": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/gulp-cli/-/gulp-cli-2.3.0.tgz", + "resolved": "https://registry.npmmirror.com/gulp-cli/-/gulp-cli-2.3.0.tgz", "integrity": "sha512-zzGBl5fHo0EKSXsHzjspp3y5CONegCm8ErO5Qh0UzFzk2y4tMvzLWhoDokADbarfZRL2pGpRp7yt6gfJX4ph7A==", "dev": true, "license": "MIT", @@ -8612,7 +8207,7 @@ }, "node_modules/gulp-cli/node_modules/fancy-log": { "version": "1.3.3", - "resolved": "https://registry.npmjs.org/fancy-log/-/fancy-log-1.3.3.tgz", + "resolved": "https://registry.npmmirror.com/fancy-log/-/fancy-log-1.3.3.tgz", "integrity": "sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==", "dev": true, "license": "MIT", @@ -8628,7 +8223,7 @@ }, "node_modules/gulp-javascript-obfuscator": { "version": "1.1.6", - "resolved": "https://registry.npmjs.org/gulp-javascript-obfuscator/-/gulp-javascript-obfuscator-1.1.6.tgz", + "resolved": "https://registry.npmmirror.com/gulp-javascript-obfuscator/-/gulp-javascript-obfuscator-1.1.6.tgz", "integrity": "sha512-oiROhi7Zlu/0fM2h20jBFPaDOZicilT6kN+97Si82yieeFqr6l70o2R3gZ2Ah0u8v5IqGa+Pt8c2q3UnkMuk2A==", "dev": true, "license": "MIT", @@ -8641,7 +8236,7 @@ }, "node_modules/gulp-rename": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/gulp-rename/-/gulp-rename-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/gulp-rename/-/gulp-rename-2.1.0.tgz", "integrity": "sha512-dGuzuH8jQGqCMqC544IEPhs5+O2l+IkdoSZsgd4kY97M1CxQeI3qrmweQBIrxLBbjbe/8uEWK8HHcNBc3OCy4g==", "dev": true, "license": "MIT", @@ -8651,7 +8246,7 @@ }, "node_modules/gulp-uglify": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/gulp-uglify/-/gulp-uglify-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/gulp-uglify/-/gulp-uglify-3.0.2.tgz", "integrity": "sha512-gk1dhB74AkV2kzqPMQBLA3jPoIAPd/nlNzP2XMDSG8XZrqnlCiDGAqC+rZOumzFvB5zOphlFh6yr3lgcAb/OOg==", "dev": true, "license": "MIT", @@ -8670,7 +8265,7 @@ }, "node_modules/gulp-uglify-es": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/gulp-uglify-es/-/gulp-uglify-es-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/gulp-uglify-es/-/gulp-uglify-es-3.0.0.tgz", "integrity": "sha512-dQ3czMFFojNgCajcrYl0oa98+YayaQ8kXRdaacpZRZ3iw2sdVURfdt8y8Ki1ogZGQqw8BUawnB7V6NkanxqnDg==", "dev": true, "license": "MIT", @@ -8684,7 +8279,7 @@ }, "node_modules/gulp-uglify/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -8698,7 +8293,7 @@ }, "node_modules/gulp-uglify/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -8711,7 +8306,7 @@ }, "node_modules/gulp-uglify/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -8724,7 +8319,7 @@ }, "node_modules/gulplog": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/gulplog/-/gulplog-1.0.0.tgz", "integrity": "sha512-hm6N8nrm3Y08jXie48jsC55eCZz9mnb4OirAStEk2deqeyhXU3C1otDVh+ccttMuc1sBi6RX6ZJ720hs9RCvgw==", "dev": true, "license": "MIT", @@ -8737,7 +8332,7 @@ }, "node_modules/has": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/has/-/has-1.0.4.tgz", "integrity": "sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==", "dev": true, "license": "MIT", @@ -8747,7 +8342,7 @@ }, "node_modules/has-ansi": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-ansi/-/has-ansi-2.0.0.tgz", "integrity": "sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==", "dev": true, "license": "MIT", @@ -8760,7 +8355,7 @@ }, "node_modules/has-ansi/node_modules/ansi-regex": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-2.1.1.tgz", "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==", "dev": true, "license": "MIT", @@ -8770,7 +8365,7 @@ }, "node_modules/has-bigints": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/has-bigints/-/has-bigints-1.1.0.tgz", "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==", "dev": true, "license": "MIT", @@ -8783,7 +8378,7 @@ }, "node_modules/has-flag": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-3.0.0.tgz", "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", "license": "MIT", "engines": { @@ -8792,7 +8387,7 @@ }, "node_modules/has-gulplog": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/has-gulplog/-/has-gulplog-0.1.0.tgz", + "resolved": "https://registry.npmmirror.com/has-gulplog/-/has-gulplog-0.1.0.tgz", "integrity": "sha512-+F4GzLjwHNNDEAJW2DC1xXfEoPkRDmUdJ7CBYw4MpqtDwOnqdImJl7GWlpqx+Wko6//J8uKTnIe4wZSv7yCqmw==", "dev": true, "license": "MIT", @@ -8805,7 +8400,7 @@ }, "node_modules/has-property-descriptors": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", "dev": true, "license": "MIT", @@ -8818,7 +8413,7 @@ }, "node_modules/has-proto": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/has-proto/-/has-proto-1.2.0.tgz", "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", "dev": true, "license": "MIT", @@ -8834,7 +8429,7 @@ }, "node_modules/has-symbols": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/has-symbols/-/has-symbols-1.1.0.tgz", "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", "dev": true, "license": "MIT", @@ -8847,7 +8442,7 @@ }, "node_modules/has-tostringtag": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz", "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", "dev": true, "license": "MIT", @@ -8863,7 +8458,7 @@ }, "node_modules/has-value": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-value/-/has-value-1.0.0.tgz", "integrity": "sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw==", "dev": true, "license": "MIT", @@ -8878,7 +8473,7 @@ }, "node_modules/has-values": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-values/-/has-values-1.0.0.tgz", "integrity": "sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ==", "dev": true, "license": "MIT", @@ -8892,7 +8487,7 @@ }, "node_modules/has-values/node_modules/kind-of": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-4.0.0.tgz", "integrity": "sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw==", "dev": true, "license": "MIT", @@ -8905,7 +8500,7 @@ }, "node_modules/hasown": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/hasown/-/hasown-2.0.2.tgz", "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", "license": "MIT", "dependencies": { @@ -8917,7 +8512,7 @@ }, "node_modules/he": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/he/-/he-1.2.0.tgz", "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", "dev": true, "license": "MIT", @@ -8927,13 +8522,13 @@ }, "node_modules/help": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/help/-/help-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/help/-/help-3.0.2.tgz", "integrity": "sha512-jDd0MU+9xzvOQRC6CIzdjvb+agCvpzQY/Fp11quDnugDO4QQzh134EsLkRQMvFIJBleFkvnXagHFm4MTefkkpA==", "license": "MIT" }, "node_modules/homedir-polyfill": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", "dev": true, "license": "MIT", @@ -8946,14 +8541,14 @@ }, "node_modules/hosted-git-info": { "version": "2.8.9", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", + "resolved": "https://registry.npmmirror.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz", "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", "dev": true, "license": "ISC" }, "node_modules/https-proxy-agent": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", "dev": true, "license": "MIT", @@ -8967,7 +8562,7 @@ }, "node_modules/human-signals": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/human-signals/-/human-signals-1.1.1.tgz", "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", "dev": true, "license": "Apache-2.0", @@ -8977,7 +8572,7 @@ }, "node_modules/ieee754": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/ieee754/-/ieee754-1.2.1.tgz", "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "dev": true, "funding": [ @@ -8998,7 +8593,7 @@ }, "node_modules/ignore": { "version": "5.3.2", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "resolved": "https://registry.npmmirror.com/ignore/-/ignore-5.3.2.tgz", "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, "license": "MIT", @@ -9008,7 +8603,7 @@ }, "node_modules/import-fresh": { "version": "3.3.1", - "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "resolved": "https://registry.npmmirror.com/import-fresh/-/import-fresh-3.3.1.tgz", "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", "dev": true, "license": "MIT", @@ -9025,7 +8620,7 @@ }, "node_modules/imurmurhash": { "version": "0.1.4", - "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "resolved": "https://registry.npmmirror.com/imurmurhash/-/imurmurhash-0.1.4.tgz", "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "dev": true, "license": "MIT", @@ -9035,7 +8630,7 @@ }, "node_modules/inflight": { "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "resolved": "https://registry.npmmirror.com/inflight/-/inflight-1.0.6.tgz", "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", "dev": true, @@ -9047,21 +8642,21 @@ }, "node_modules/inherits": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/inherits/-/inherits-2.0.4.tgz", "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", "dev": true, "license": "ISC" }, "node_modules/ini": { "version": "1.3.8", - "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "resolved": "https://registry.npmmirror.com/ini/-/ini-1.3.8.tgz", "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", "dev": true, "license": "ISC" }, "node_modules/internal-slot": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/internal-slot/-/internal-slot-1.1.0.tgz", "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", "dev": true, "license": "MIT", @@ -9076,7 +8671,7 @@ }, "node_modules/interpret": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/interpret/-/interpret-1.4.0.tgz", "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", "dev": true, "license": "MIT", @@ -9086,7 +8681,7 @@ }, "node_modules/into-stream": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/into-stream/-/into-stream-6.0.0.tgz", + "resolved": "https://registry.npmmirror.com/into-stream/-/into-stream-6.0.0.tgz", "integrity": "sha512-XHbaOAvP+uFKUFsOgoNPRjLkwB+I22JFPFe5OjTkQ0nwgj6+pSjb4NmB6VMxaPshLiOf+zcpOCBQuLwC1KHhZA==", "dev": true, "license": "MIT", @@ -9103,7 +8698,7 @@ }, "node_modules/invariant": { "version": "2.2.4", - "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", + "resolved": "https://registry.npmmirror.com/invariant/-/invariant-2.2.4.tgz", "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", "dev": true, "license": "MIT", @@ -9113,7 +8708,7 @@ }, "node_modules/inversify": { "version": "6.1.4", - "resolved": "https://registry.npmjs.org/inversify/-/inversify-6.1.4.tgz", + "resolved": "https://registry.npmmirror.com/inversify/-/inversify-6.1.4.tgz", "integrity": "sha512-PbxrZH/gTa1fpPEEGAjJQzK8tKMIp5gRg6EFNJlCtzUcycuNdmhv3uk5P8Itm/RIjgHJO16oQRLo9IHzQN51bA==", "dev": true, "license": "MIT", @@ -9124,7 +8719,7 @@ }, "node_modules/invert-kv": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/invert-kv/-/invert-kv-1.0.0.tgz", "integrity": "sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==", "dev": true, "license": "MIT", @@ -9134,7 +8729,7 @@ }, "node_modules/is-absolute": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-absolute/-/is-absolute-1.0.0.tgz", "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==", "dev": true, "license": "MIT", @@ -9148,7 +8743,7 @@ }, "node_modules/is-accessor-descriptor": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.1.tgz", "integrity": "sha512-YBUanLI8Yoihw923YeFUS5fs0fF2f5TSFTNiYAAzhhDscDa3lEqYuz1pDOEP5KvX94I9ey3vsqjJcLVFVU+3QA==", "dev": true, "license": "MIT", @@ -9161,7 +8756,7 @@ }, "node_modules/is-arguments": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/is-arguments/-/is-arguments-1.2.0.tgz", "integrity": "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==", "dev": true, "license": "MIT", @@ -9178,7 +8773,7 @@ }, "node_modules/is-array-buffer": { "version": "3.0.5", - "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "resolved": "https://registry.npmmirror.com/is-array-buffer/-/is-array-buffer-3.0.5.tgz", "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", "dev": true, "license": "MIT", @@ -9196,14 +8791,14 @@ }, "node_modules/is-arrayish": { "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "resolved": "https://registry.npmmirror.com/is-arrayish/-/is-arrayish-0.2.1.tgz", "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", "dev": true, "license": "MIT" }, "node_modules/is-async-function": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-async-function/-/is-async-function-2.1.1.tgz", "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==", "dev": true, "license": "MIT", @@ -9223,7 +8818,7 @@ }, "node_modules/is-bigint": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-bigint/-/is-bigint-1.1.0.tgz", "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", "dev": true, "license": "MIT", @@ -9239,7 +8834,7 @@ }, "node_modules/is-binary-path": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-binary-path/-/is-binary-path-1.0.1.tgz", "integrity": "sha512-9fRVlXc0uCxEDj1nQzaWONSpbTfx0FmJfzHF7pwlI8DkWGoHBBea4Pg5Ky0ojwwxQmnSifgbKkI06Qv0Ljgj+Q==", "dev": true, "license": "MIT", @@ -9252,7 +8847,7 @@ }, "node_modules/is-boolean-object": { "version": "1.2.2", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz", + "resolved": "https://registry.npmmirror.com/is-boolean-object/-/is-boolean-object-1.2.2.tgz", "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==", "dev": true, "license": "MIT", @@ -9269,14 +8864,14 @@ }, "node_modules/is-buffer": { "version": "1.1.6", - "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "resolved": "https://registry.npmmirror.com/is-buffer/-/is-buffer-1.1.6.tgz", "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true, "license": "MIT" }, "node_modules/is-callable": { "version": "1.2.7", - "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "resolved": "https://registry.npmmirror.com/is-callable/-/is-callable-1.2.7.tgz", "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", "dev": true, "license": "MIT", @@ -9289,13 +8884,13 @@ }, "node_modules/is-class-hotfix": { "version": "0.0.6", - "resolved": "https://registry.npmjs.org/is-class-hotfix/-/is-class-hotfix-0.0.6.tgz", + "resolved": "https://registry.npmmirror.com/is-class-hotfix/-/is-class-hotfix-0.0.6.tgz", "integrity": "sha512-0n+pzCC6ICtVr/WXnN2f03TK/3BfXY7me4cjCAqT8TYXEl0+JBRoqBo94JJHXcyDSLUeWbNX8Fvy5g5RJdAstQ==", "license": "MIT" }, "node_modules/is-core-module": { "version": "2.16.1", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "resolved": "https://registry.npmmirror.com/is-core-module/-/is-core-module-2.16.1.tgz", "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", "license": "MIT", "dependencies": { @@ -9310,7 +8905,7 @@ }, "node_modules/is-data-descriptor": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-data-descriptor/-/is-data-descriptor-1.0.1.tgz", "integrity": "sha512-bc4NlCDiCr28U4aEsQ3Qs2491gVq4V8G7MQyws968ImqjKuYtTJXrl7Vq7jsN7Ly/C3xj5KWFrY7sHNeDkAzXw==", "dev": true, "license": "MIT", @@ -9323,7 +8918,7 @@ }, "node_modules/is-data-view": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/is-data-view/-/is-data-view-1.0.2.tgz", "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", "dev": true, "license": "MIT", @@ -9341,7 +8936,7 @@ }, "node_modules/is-date-object": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-date-object/-/is-date-object-1.1.0.tgz", "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", "dev": true, "license": "MIT", @@ -9358,7 +8953,7 @@ }, "node_modules/is-descriptor": { "version": "0.1.7", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.7.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-0.1.7.tgz", "integrity": "sha512-C3grZTvObeN1xud4cRWl366OMXZTj0+HGyk4hvfpx4ZHt1Pb60ANSXqCK7pdOTeUQpRzECBSTphqvD7U+l22Eg==", "dev": true, "license": "MIT", @@ -9372,7 +8967,7 @@ }, "node_modules/is-expression": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-expression/-/is-expression-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-expression/-/is-expression-4.0.0.tgz", "integrity": "sha512-zMIXX63sxzG3XrkHkrAPvm/OVZVSCPNkwMHU8oTX7/U3AL78I0QXCEICXUM13BIa8TYGZ68PiTKfQz3yaTNr4A==", "dev": true, "license": "MIT", @@ -9383,7 +8978,7 @@ }, "node_modules/is-expression/node_modules/acorn": { "version": "7.4.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", + "resolved": "https://registry.npmmirror.com/acorn/-/acorn-7.4.1.tgz", "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", "dev": true, "license": "MIT", @@ -9396,7 +8991,7 @@ }, "node_modules/is-extendable": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-0.1.1.tgz", "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", "dev": true, "license": "MIT", @@ -9406,7 +9001,7 @@ }, "node_modules/is-extglob": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", "license": "MIT", "engines": { @@ -9415,7 +9010,7 @@ }, "node_modules/is-finalizationregistry": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", "dev": true, "license": "MIT", @@ -9431,7 +9026,7 @@ }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true, "license": "MIT", @@ -9441,7 +9036,7 @@ }, "node_modules/is-generator-function": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/is-generator-function/-/is-generator-function-1.1.2.tgz", "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==", "dev": true, "license": "MIT", @@ -9461,7 +9056,7 @@ }, "node_modules/is-glob": { "version": "4.0.3", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", "license": "MIT", "dependencies": { @@ -9473,7 +9068,7 @@ }, "node_modules/is-map": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-map/-/is-map-2.0.3.tgz", "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==", "dev": true, "license": "MIT", @@ -9486,7 +9081,7 @@ }, "node_modules/is-nan": { "version": "1.3.2", - "resolved": "https://registry.npmjs.org/is-nan/-/is-nan-1.3.2.tgz", + "resolved": "https://registry.npmmirror.com/is-nan/-/is-nan-1.3.2.tgz", "integrity": "sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==", "dev": true, "license": "MIT", @@ -9503,7 +9098,7 @@ }, "node_modules/is-negated-glob": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-negated-glob/-/is-negated-glob-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-negated-glob/-/is-negated-glob-1.0.0.tgz", "integrity": "sha512-czXVVn/QEmgvej1f50BZ648vUI+em0xqMq2Sn+QncCLN4zj1UAxlT+kw/6ggQTOaZPd1HqKQGEqbpQVtJucWug==", "dev": true, "license": "MIT", @@ -9513,7 +9108,7 @@ }, "node_modules/is-negative-zero": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-negative-zero/-/is-negative-zero-2.0.3.tgz", "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==", "dev": true, "license": "MIT", @@ -9526,7 +9121,7 @@ }, "node_modules/is-number": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-3.0.0.tgz", "integrity": "sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg==", "dev": true, "license": "MIT", @@ -9539,7 +9134,7 @@ }, "node_modules/is-number-object": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-number-object/-/is-number-object-1.1.1.tgz", "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", "dev": true, "license": "MIT", @@ -9556,7 +9151,7 @@ }, "node_modules/is-number/node_modules/kind-of": { "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==", "dev": true, "license": "MIT", @@ -9569,7 +9164,7 @@ }, "node_modules/is-path-inside": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-path-inside/-/is-path-inside-3.0.3.tgz", "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", "dev": true, "license": "MIT", @@ -9579,7 +9174,7 @@ }, "node_modules/is-plain-obj": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz", "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", "dev": true, "license": "MIT", @@ -9589,7 +9184,7 @@ }, "node_modules/is-plain-object": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-5.0.0.tgz", "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", "dev": true, "license": "MIT", @@ -9599,14 +9194,14 @@ }, "node_modules/is-promise": { "version": "2.2.2", - "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.2.2.tgz", + "resolved": "https://registry.npmmirror.com/is-promise/-/is-promise-2.2.2.tgz", "integrity": "sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==", "dev": true, "license": "MIT" }, "node_modules/is-regex": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/is-regex/-/is-regex-1.2.1.tgz", "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", "dev": true, "license": "MIT", @@ -9625,7 +9220,7 @@ }, "node_modules/is-relative": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-relative/-/is-relative-1.0.0.tgz", "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==", "dev": true, "license": "MIT", @@ -9638,7 +9233,7 @@ }, "node_modules/is-set": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-set/-/is-set-2.0.3.tgz", "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==", "dev": true, "license": "MIT", @@ -9651,7 +9246,7 @@ }, "node_modules/is-shared-array-buffer": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==", "dev": true, "license": "MIT", @@ -9667,7 +9262,7 @@ }, "node_modules/is-stream": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-stream/-/is-stream-2.0.1.tgz", "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", "dev": true, "license": "MIT", @@ -9680,7 +9275,7 @@ }, "node_modules/is-string": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-string/-/is-string-1.1.1.tgz", "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", "dev": true, "license": "MIT", @@ -9697,7 +9292,7 @@ }, "node_modules/is-symbol": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-symbol/-/is-symbol-1.1.1.tgz", "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", "dev": true, "license": "MIT", @@ -9715,7 +9310,7 @@ }, "node_modules/is-type-of": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/is-type-of/-/is-type-of-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/is-type-of/-/is-type-of-1.4.0.tgz", "integrity": "sha512-EddYllaovi5ysMLMEN7yzHEKh8A850cZ7pykrY1aNRQGn/CDjRDE9qEWbIdt7xGEVJmjBXzU/fNnC4ABTm8tEQ==", "license": "MIT", "dependencies": { @@ -9726,7 +9321,7 @@ }, "node_modules/is-typed-array": { "version": "1.1.15", - "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "resolved": "https://registry.npmmirror.com/is-typed-array/-/is-typed-array-1.1.15.tgz", "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", "dev": true, "license": "MIT", @@ -9742,7 +9337,7 @@ }, "node_modules/is-unc-path": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-unc-path/-/is-unc-path-1.0.0.tgz", "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==", "dev": true, "license": "MIT", @@ -9755,14 +9350,14 @@ }, "node_modules/is-utf8": { "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "resolved": "https://registry.npmmirror.com/is-utf8/-/is-utf8-0.2.1.tgz", "integrity": "sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==", "dev": true, "license": "MIT" }, "node_modules/is-valid-glob": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-valid-glob/-/is-valid-glob-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-valid-glob/-/is-valid-glob-1.0.0.tgz", "integrity": "sha512-AhiROmoEFDSsjx8hW+5sGwgKVIORcXnrlAx/R0ZSeaPw70Vw0CqkGBBhHGL58Uox2eXnU1AnvXJl1XlyedO5bA==", "dev": true, "license": "MIT", @@ -9772,7 +9367,7 @@ }, "node_modules/is-weakmap": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/is-weakmap/-/is-weakmap-2.0.2.tgz", "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==", "dev": true, "license": "MIT", @@ -9785,7 +9380,7 @@ }, "node_modules/is-weakref": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/is-weakref/-/is-weakref-1.1.1.tgz", "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==", "dev": true, "license": "MIT", @@ -9801,7 +9396,7 @@ }, "node_modules/is-weakset": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-weakset/-/is-weakset-2.0.4.tgz", "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", "dev": true, "license": "MIT", @@ -9818,7 +9413,7 @@ }, "node_modules/is-windows": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/is-windows/-/is-windows-1.0.2.tgz", "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", "dev": true, "license": "MIT", @@ -9828,21 +9423,21 @@ }, "node_modules/isarray": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/isarray/-/isarray-1.0.0.tgz", "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", "dev": true, "license": "MIT" }, "node_modules/isexe": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/isexe/-/isexe-2.0.0.tgz", "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", "dev": true, "license": "ISC" }, "node_modules/isobject": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/isobject/-/isobject-3.0.1.tgz", "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==", "dev": true, "license": "MIT", @@ -9852,13 +9447,13 @@ }, "node_modules/isstream": { "version": "0.1.2", - "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "resolved": "https://registry.npmmirror.com/isstream/-/isstream-0.1.2.tgz", "integrity": "sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==", "license": "MIT" }, "node_modules/javascript-obfuscator": { "version": "4.2.2", - "resolved": "https://registry.npmjs.org/javascript-obfuscator/-/javascript-obfuscator-4.2.2.tgz", + "resolved": "https://registry.npmmirror.com/javascript-obfuscator/-/javascript-obfuscator-4.2.2.tgz", "integrity": "sha512-+7oXAUnFCA6vS0omIGHcWpSr67dUBIF7FKGYSXyzxShSLqM6LBgdugWKFl0XrYtGWyJMGfQR5F4LL85iCefkRA==", "dev": true, "license": "BSD-2-Clause", @@ -9896,7 +9491,7 @@ }, "node_modules/javascript-obfuscator/node_modules/acorn": { "version": "8.15.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.15.0.tgz", "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", @@ -9909,7 +9504,7 @@ }, "node_modules/javascript-obfuscator/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -9925,7 +9520,7 @@ }, "node_modules/javascript-obfuscator/node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", @@ -9942,7 +9537,7 @@ }, "node_modules/javascript-obfuscator/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -9955,14 +9550,14 @@ }, "node_modules/javascript-obfuscator/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/javascript-obfuscator/node_modules/commander": { "version": "12.1.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz", + "resolved": "https://registry.npmmirror.com/commander/-/commander-12.1.0.tgz", "integrity": "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==", "dev": true, "license": "MIT", @@ -9972,7 +9567,7 @@ }, "node_modules/javascript-obfuscator/node_modules/eslint-scope": { "version": "8.4.0", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "resolved": "https://registry.npmmirror.com/eslint-scope/-/eslint-scope-8.4.0.tgz", "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", "dev": true, "license": "BSD-2-Clause", @@ -9989,7 +9584,7 @@ }, "node_modules/javascript-obfuscator/node_modules/eslint-visitor-keys": { "version": "4.2.1", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "resolved": "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", "dev": true, "license": "Apache-2.0", @@ -10002,7 +9597,7 @@ }, "node_modules/javascript-obfuscator/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -10012,7 +9607,7 @@ }, "node_modules/javascript-obfuscator/node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "license": "MIT", @@ -10025,7 +9620,7 @@ }, "node_modules/jest-worker": { "version": "27.5.1", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "resolved": "https://registry.npmmirror.com/jest-worker/-/jest-worker-27.5.1.tgz", "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", "dev": true, "license": "MIT", @@ -10040,7 +9635,7 @@ }, "node_modules/jest-worker/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -10050,7 +9645,7 @@ }, "node_modules/jest-worker/node_modules/supports-color": { "version": "8.1.1", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-8.1.1.tgz", "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "license": "MIT", @@ -10066,7 +9661,7 @@ }, "node_modules/js-string-escape": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/js-string-escape/-/js-string-escape-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/js-string-escape/-/js-string-escape-1.0.1.tgz", "integrity": "sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==", "dev": true, "license": "MIT", @@ -10076,20 +9671,20 @@ }, "node_modules/js-stringify": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/js-stringify/-/js-stringify-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/js-stringify/-/js-stringify-1.0.2.tgz", "integrity": "sha512-rtS5ATOo2Q5k1G+DADISilDA6lv79zIiwFd6CcjuIxGKLFm5C+RLImRscVap9k55i+MOZwgliw+NejvkLuGD5g==", "dev": true, "license": "MIT" }, "node_modules/js-tokens": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/js-tokens/-/js-tokens-4.0.0.tgz", "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", "license": "MIT" }, "node_modules/js-yaml": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "resolved": "https://registry.npmmirror.com/js-yaml/-/js-yaml-4.1.1.tgz", "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", "dev": true, "license": "MIT", @@ -10102,7 +9697,7 @@ }, "node_modules/js2xmlparser": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.2.tgz", + "resolved": "https://registry.npmmirror.com/js2xmlparser/-/js2xmlparser-4.0.2.tgz", "integrity": "sha512-6n4D8gLlLf1n5mNLQPRfViYzu9RATblzPEtm1SthMX1Pjao0r9YI9nw7ZIfRxQMERS87mcswrg+r/OYrPRX6jA==", "dev": true, "license": "Apache-2.0", @@ -10112,7 +9707,7 @@ }, "node_modules/jscpd": { "version": "4.0.8", - "resolved": "https://registry.npmjs.org/jscpd/-/jscpd-4.0.8.tgz", + "resolved": "https://registry.npmmirror.com/jscpd/-/jscpd-4.0.8.tgz", "integrity": "sha512-d2VNT/2Hv4dxT2/59He8Lyda4DYOxPRyRG9zBaOpTZAqJCVf2xLrBlZkT8Va6Lo9u3X2qz8Bpq4HrDi4JsrQhA==", "dev": true, "license": "MIT", @@ -10134,7 +9729,7 @@ }, "node_modules/jscpd-sarif-reporter": { "version": "4.0.6", - "resolved": "https://registry.npmjs.org/jscpd-sarif-reporter/-/jscpd-sarif-reporter-4.0.6.tgz", + "resolved": "https://registry.npmmirror.com/jscpd-sarif-reporter/-/jscpd-sarif-reporter-4.0.6.tgz", "integrity": "sha512-b9Sm3IPZ3+m8Lwa4gZa+4/LhDhlc/ZLEsLXKSOy1DANQ6kx0ueqZT+fUHWEdQ6m0o3+RIVIa7DmvLSojQD05ng==", "dev": true, "license": "MIT", @@ -10146,7 +9741,7 @@ }, "node_modules/jscpd-sarif-reporter/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -10161,7 +9756,7 @@ }, "node_modules/jscpd-sarif-reporter/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -10174,7 +9769,7 @@ }, "node_modules/jscpd-sarif-reporter/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -10184,7 +9779,7 @@ }, "node_modules/jscpd/node_modules/commander": { "version": "5.1.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz", + "resolved": "https://registry.npmmirror.com/commander/-/commander-5.1.0.tgz", "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==", "dev": true, "license": "MIT", @@ -10194,7 +9789,7 @@ }, "node_modules/jscpd/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -10209,7 +9804,7 @@ }, "node_modules/jscpd/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -10222,7 +9817,7 @@ }, "node_modules/jscpd/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -10232,7 +9827,7 @@ }, "node_modules/jsdoc": { "version": "4.0.5", - "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-4.0.5.tgz", + "resolved": "https://registry.npmmirror.com/jsdoc/-/jsdoc-4.0.5.tgz", "integrity": "sha512-P4C6MWP9yIlMiK8nwoZvxN84vb6MsnXcHuy7XzVOvQoCizWX5JFCBsWIIWKXBltpoRZXddUOVQmCTOZt9yDj9g==", "dev": true, "license": "Apache-2.0", @@ -10262,7 +9857,7 @@ }, "node_modules/jsdoc-type-pratt-parser": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-4.1.0.tgz", + "resolved": "https://registry.npmmirror.com/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-4.1.0.tgz", "integrity": "sha512-Hicd6JK5Njt2QB6XYFS7ok9e37O8AYk3jTcppG4YVQnYjOemymvTcmc7OWsmq/Qqj5TdRFO5/x/tIPmBeRtGHg==", "dev": true, "license": "MIT", @@ -10272,7 +9867,7 @@ }, "node_modules/jsdoc/node_modules/escape-string-regexp": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", "dev": true, "license": "MIT", @@ -10282,7 +9877,7 @@ }, "node_modules/jsdoc/node_modules/mkdirp": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/mkdirp/-/mkdirp-1.0.4.tgz", "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", "dev": true, "license": "MIT", @@ -10295,7 +9890,7 @@ }, "node_modules/jsesc": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/jsesc/-/jsesc-3.1.0.tgz", "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", "license": "MIT", "bin": { @@ -10307,42 +9902,42 @@ }, "node_modules/json-buffer": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/json-buffer/-/json-buffer-3.0.1.tgz", "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", "dev": true, "license": "MIT" }, "node_modules/json-parse-even-better-errors": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "resolved": "https://registry.npmmirror.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", "dev": true, "license": "MIT" }, "node_modules/json-schema-traverse": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "resolved": "https://registry.npmmirror.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", "dev": true, "license": "MIT" }, "node_modules/json-schema-typed": { "version": "8.0.2", - "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz", + "resolved": "https://registry.npmmirror.com/json-schema-typed/-/json-schema-typed-8.0.2.tgz", "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==", "dev": true, "license": "BSD-2-Clause" }, "node_modules/json-stable-stringify-without-jsonify": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", "dev": true, "license": "MIT" }, "node_modules/json5": { "version": "2.2.3", - "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "resolved": "https://registry.npmmirror.com/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", "license": "MIT", "bin": { @@ -10354,7 +9949,7 @@ }, "node_modules/jsondiffpatch": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/jsondiffpatch/-/jsondiffpatch-0.4.1.tgz", + "resolved": "https://registry.npmmirror.com/jsondiffpatch/-/jsondiffpatch-0.4.1.tgz", "integrity": "sha512-t0etAxTUk1w5MYdNOkZBZ8rvYYN5iL+2dHCCx/DpkFm/bW28M6y5nUS83D4XdZiHy35Fpaw6LBb+F88fHZnVCw==", "license": "MIT", "dependencies": { @@ -10370,7 +9965,7 @@ }, "node_modules/jsonfile": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-5.0.0.tgz", "integrity": "sha512-NQRZ5CRo74MhMMC3/3r5g2k4fjodJ/wh8MxjFbCViWKFjxrnudWSY5vomh+23ZaXzAS7J3fBZIR2dV6WbmfM0w==", "license": "MIT", "dependencies": { @@ -10382,7 +9977,7 @@ }, "node_modules/jsonparse": { "version": "1.3.1", - "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "resolved": "https://registry.npmmirror.com/jsonparse/-/jsonparse-1.3.1.tgz", "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", "engines": [ "node >= 0.2.0" @@ -10391,7 +9986,7 @@ }, "node_modules/JSONStream": { "version": "1.3.5", - "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", + "resolved": "https://registry.npmmirror.com/JSONStream/-/JSONStream-1.3.5.tgz", "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", "license": "(MIT OR Apache-2.0)", "dependencies": { @@ -10407,7 +10002,7 @@ }, "node_modules/jstransformer": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/jstransformer/-/jstransformer-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/jstransformer/-/jstransformer-1.0.0.tgz", "integrity": "sha512-C9YK3Rf8q6VAPDCCU9fnqo3mAfOH6vUGnMcP4AQAYIEpWtfGLpwOTmZ+igtdK5y+VvI2n3CyYSzy4Qh34eq24A==", "dev": true, "license": "MIT", @@ -10418,14 +10013,14 @@ }, "node_modules/just-debounce": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/just-debounce/-/just-debounce-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/just-debounce/-/just-debounce-1.1.0.tgz", "integrity": "sha512-qpcRocdkUmf+UTNBYx5w6dexX5J31AKK1OmPwH630a83DdVVUIngk55RSAiIGpQyoH0dlr872VHfPjnQnK1qDQ==", "dev": true, "license": "MIT" }, "node_modules/keyv": { "version": "4.5.4", - "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "resolved": "https://registry.npmmirror.com/keyv/-/keyv-4.5.4.tgz", "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", "dev": true, "license": "MIT", @@ -10435,7 +10030,7 @@ }, "node_modules/kind-of": { "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-5.1.0.tgz", "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", "dev": true, "license": "MIT", @@ -10445,7 +10040,7 @@ }, "node_modules/klaw": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/klaw/-/klaw-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/klaw/-/klaw-3.0.0.tgz", "integrity": "sha512-0Fo5oir+O9jnXu5EefYbVK+mHMBeEVEy2cmctR1O1NECcCkPRreJKrS6Qt/j3KC2C148Dfo9i3pCmCMsdqGr0g==", "dev": true, "license": "MIT", @@ -10455,7 +10050,7 @@ }, "node_modules/last-run": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/last-run/-/last-run-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/last-run/-/last-run-1.1.1.tgz", "integrity": "sha512-U/VxvpX4N/rFvPzr3qG5EtLKEnNI0emvIQB3/ecEwv+8GHaUKbIB8vxv1Oai5FAF0d0r7LXHhLLe5K/yChm5GQ==", "dev": true, "license": "MIT", @@ -10469,7 +10064,7 @@ }, "node_modules/lazystream": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/lazystream/-/lazystream-1.0.1.tgz", "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==", "dev": true, "license": "MIT", @@ -10482,7 +10077,7 @@ }, "node_modules/lcid": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/lcid/-/lcid-1.0.0.tgz", "integrity": "sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==", "dev": true, "license": "MIT", @@ -10495,7 +10090,7 @@ }, "node_modules/lead": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lead/-/lead-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/lead/-/lead-1.0.0.tgz", "integrity": "sha512-IpSVCk9AYvLHo5ctcIXxOBpMWUe+4TKN3VPWAKUbJikkmsGp0VrSM8IttVc32D6J4WUsiPE6aEFRNmIoF/gdow==", "dev": true, "license": "MIT", @@ -10508,7 +10103,7 @@ }, "node_modules/levn": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "resolved": "https://registry.npmmirror.com/levn/-/levn-0.4.1.tgz", "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", "dev": true, "license": "MIT", @@ -10522,14 +10117,14 @@ }, "node_modules/libphonenumber-js": { "version": "1.12.41", - "resolved": "https://registry.npmjs.org/libphonenumber-js/-/libphonenumber-js-1.12.41.tgz", + "resolved": "https://registry.npmmirror.com/libphonenumber-js/-/libphonenumber-js-1.12.41.tgz", "integrity": "sha512-lsmMmGXBxXIK/VMLEj0kL6MtUs1kBGj1nTCzi6zgQoG1DEwqwt2DQyHxcLykceIxAnfE3hya7NuIh6PpC6S3fA==", "dev": true, "license": "MIT" }, "node_modules/liftoff": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/liftoff/-/liftoff-3.1.0.tgz", "integrity": "sha512-DlIPlJUkCV0Ips2zf2pJP0unEoT1kwYhiiPUGF3s/jtxTCjziNLoiVVh+jqWOWeFi6mmwQ5fNxvAUyPad4Dfog==", "dev": true, "license": "MIT", @@ -10549,7 +10144,7 @@ }, "node_modules/liftoff/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -10562,7 +10157,7 @@ }, "node_modules/linkify-it": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/linkify-it/-/linkify-it-5.0.0.tgz", "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==", "dev": true, "license": "MIT", @@ -10572,7 +10167,7 @@ }, "node_modules/load-json-file": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/load-json-file/-/load-json-file-1.1.0.tgz", "integrity": "sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==", "dev": true, "license": "MIT", @@ -10589,7 +10184,7 @@ }, "node_modules/load-json-file/node_modules/strip-bom": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/strip-bom/-/strip-bom-2.0.0.tgz", "integrity": "sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==", "dev": true, "license": "MIT", @@ -10602,7 +10197,7 @@ }, "node_modules/loader-runner": { "version": "4.3.1", - "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.1.tgz", + "resolved": "https://registry.npmmirror.com/loader-runner/-/loader-runner-4.3.1.tgz", "integrity": "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q==", "dev": true, "license": "MIT", @@ -10616,7 +10211,7 @@ }, "node_modules/locate-path": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "resolved": "https://registry.npmmirror.com/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "license": "MIT", @@ -10632,54 +10227,54 @@ }, "node_modules/lodash": { "version": "4.18.1", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz", + "resolved": "https://registry.npmmirror.com/lodash/-/lodash-4.18.1.tgz", "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==", "license": "MIT" }, "node_modules/lodash.camelcase": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", "dev": true, "license": "MIT" }, "node_modules/lodash.debounce": { "version": "4.0.8", - "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "resolved": "https://registry.npmmirror.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz", "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==", "license": "MIT" }, "node_modules/lodash.kebabcase": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz", + "resolved": "https://registry.npmmirror.com/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz", "integrity": "sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==", "dev": true, "license": "MIT" }, "node_modules/lodash.merge": { "version": "4.6.2", - "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "resolved": "https://registry.npmmirror.com/lodash.merge/-/lodash.merge-4.6.2.tgz", "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", "dev": true, "license": "MIT" }, "node_modules/lodash.snakecase": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz", + "resolved": "https://registry.npmmirror.com/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz", "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==", "dev": true, "license": "MIT" }, "node_modules/lodash.upperfirst": { "version": "4.3.1", - "resolved": "https://registry.npmjs.org/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz", + "resolved": "https://registry.npmmirror.com/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz", "integrity": "sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==", "dev": true, "license": "MIT" }, "node_modules/log-symbols": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/log-symbols/-/log-symbols-4.0.0.tgz", "integrity": "sha512-FN8JBzLx6CzeMrB0tg6pqlGU1wCrXW+ZXGH481kfsBqer0hToTIiHdjH4Mq8xJUbvATujKCvaREGWpGUionraA==", "dev": true, "license": "MIT", @@ -10692,7 +10287,7 @@ }, "node_modules/log-symbols/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -10708,7 +10303,7 @@ }, "node_modules/log-symbols/node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", @@ -10725,7 +10320,7 @@ }, "node_modules/log-symbols/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -10738,14 +10333,14 @@ }, "node_modules/log-symbols/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/log-symbols/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -10755,7 +10350,7 @@ }, "node_modules/log-symbols/node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "license": "MIT", @@ -10768,7 +10363,7 @@ }, "node_modules/log4js": { "version": "6.9.1", - "resolved": "https://registry.npmjs.org/log4js/-/log4js-6.9.1.tgz", + "resolved": "https://registry.npmmirror.com/log4js/-/log4js-6.9.1.tgz", "integrity": "sha512-1somDdy9sChrr9/f4UlzhdaGfDR2c/SaD2a4T7qEkG4jTS57/B3qmnjLYePwQ8cqWnUHZI0iAKxMBpCZICiZ2g==", "license": "Apache-2.0", "dependencies": { @@ -10784,7 +10379,7 @@ }, "node_modules/loose-envify": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/loose-envify/-/loose-envify-1.4.0.tgz", "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", "dev": true, "license": "MIT", @@ -10797,7 +10392,7 @@ }, "node_modules/loupe": { "version": "2.3.7", - "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz", + "resolved": "https://registry.npmmirror.com/loupe/-/loupe-2.3.7.tgz", "integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==", "dev": true, "license": "MIT", @@ -10807,7 +10402,7 @@ }, "node_modules/lru-cache": { "version": "5.1.1", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "resolved": "https://registry.npmmirror.com/lru-cache/-/lru-cache-5.1.1.tgz", "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", "license": "ISC", "dependencies": { @@ -10816,14 +10411,14 @@ }, "node_modules/make-error": { "version": "1.3.6", - "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "resolved": "https://registry.npmmirror.com/make-error/-/make-error-1.3.6.tgz", "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", "dev": true, "license": "ISC" }, "node_modules/make-error-cause": { "version": "1.2.2", - "resolved": "https://registry.npmjs.org/make-error-cause/-/make-error-cause-1.2.2.tgz", + "resolved": "https://registry.npmmirror.com/make-error-cause/-/make-error-cause-1.2.2.tgz", "integrity": "sha512-4TO2Y3HkBnis4c0dxhAgD/jprySYLACf7nwN6V0HAHDx59g12WlRpUmFy1bRHamjGUEEBrEvCq6SUpsEE2lhUg==", "dev": true, "license": "Apache-2.0", @@ -10833,7 +10428,7 @@ }, "node_modules/make-iterator": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/make-iterator/-/make-iterator-1.0.1.tgz", "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", "dev": true, "license": "MIT", @@ -10846,7 +10441,7 @@ }, "node_modules/make-iterator/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -10856,7 +10451,7 @@ }, "node_modules/map-cache": { "version": "0.2.2", - "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", + "resolved": "https://registry.npmmirror.com/map-cache/-/map-cache-0.2.2.tgz", "integrity": "sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==", "dev": true, "license": "MIT", @@ -10866,7 +10461,7 @@ }, "node_modules/map-visit": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/map-visit/-/map-visit-1.0.0.tgz", "integrity": "sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w==", "dev": true, "license": "MIT", @@ -10879,7 +10474,7 @@ }, "node_modules/markdown-it": { "version": "14.1.1", - "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.1.tgz", + "resolved": "https://registry.npmmirror.com/markdown-it/-/markdown-it-14.1.1.tgz", "integrity": "sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==", "dev": true, "license": "MIT", @@ -10897,7 +10492,7 @@ }, "node_modules/markdown-it-anchor": { "version": "8.6.7", - "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-8.6.7.tgz", + "resolved": "https://registry.npmmirror.com/markdown-it-anchor/-/markdown-it-anchor-8.6.7.tgz", "integrity": "sha512-FlCHFwNnutLgVTflOYHPW2pPcl2AACqVzExlkGQNsi4CJgqOHN7YTgDd4LuhgN1BFO3TS0vLAruV1Td6dwWPJA==", "dev": true, "license": "Unlicense", @@ -10908,7 +10503,7 @@ }, "node_modules/markdown-table": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/markdown-table/-/markdown-table-2.0.0.tgz", "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==", "dev": true, "license": "MIT", @@ -10922,7 +10517,7 @@ }, "node_modules/marked": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/marked/-/marked-4.3.0.tgz", "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==", "dev": true, "license": "MIT", @@ -10935,7 +10530,7 @@ }, "node_modules/matchdep": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/matchdep/-/matchdep-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/matchdep/-/matchdep-2.0.0.tgz", "integrity": "sha512-LFgVbaHIHMqCRuCZyfCtUOq9/Lnzhi7Z0KFUE2fhD54+JN2jLh3hC02RLkqauJ3U4soU6H1J3tfj/Byk7GoEjA==", "dev": true, "license": "MIT", @@ -10951,7 +10546,7 @@ }, "node_modules/matchdep/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -10965,7 +10560,7 @@ }, "node_modules/matchdep/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -10979,7 +10574,7 @@ }, "node_modules/matchdep/node_modules/findup-sync": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/findup-sync/-/findup-sync-2.0.0.tgz", "integrity": "sha512-vs+3unmJT45eczmcAZ6zMJtxN3l/QXeccaXQx5cu/MeJMhewVfoWZqibRkOxPnmoR59+Zy5hjabfQc6JLSah4g==", "dev": true, "license": "MIT", @@ -10995,7 +10590,7 @@ }, "node_modules/matchdep/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -11009,7 +10604,7 @@ }, "node_modules/matchdep/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -11022,7 +10617,7 @@ }, "node_modules/matchdep/node_modules/is-glob": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-3.1.0.tgz", "integrity": "sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==", "dev": true, "license": "MIT", @@ -11035,7 +10630,7 @@ }, "node_modules/matchdep/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -11048,7 +10643,7 @@ }, "node_modules/matchdep/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -11058,7 +10653,7 @@ }, "node_modules/matchdep/node_modules/micromatch": { "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-3.1.10.tgz", "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "license": "MIT", @@ -11083,7 +10678,7 @@ }, "node_modules/math-intrinsics": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz", "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", "dev": true, "license": "MIT", @@ -11093,7 +10688,7 @@ }, "node_modules/md5": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz", + "resolved": "https://registry.npmmirror.com/md5/-/md5-2.3.0.tgz", "integrity": "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==", "dev": true, "license": "BSD-3-Clause", @@ -11105,21 +10700,21 @@ }, "node_modules/mdurl": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/mdurl/-/mdurl-2.0.0.tgz", "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==", "dev": true, "license": "MIT" }, "node_modules/merge-stream": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/merge-stream/-/merge-stream-2.0.0.tgz", "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", "dev": true, "license": "MIT" }, "node_modules/merge2": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "resolved": "https://registry.npmmirror.com/merge2/-/merge2-1.4.1.tgz", "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", "license": "MIT", "engines": { @@ -11128,7 +10723,7 @@ }, "node_modules/micromatch": { "version": "4.0.8", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-4.0.8.tgz", "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "license": "MIT", "dependencies": { @@ -11141,7 +10736,7 @@ }, "node_modules/micromatch/node_modules/braces": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "resolved": "https://registry.npmmirror.com/braces/-/braces-3.0.3.tgz", "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", "license": "MIT", "dependencies": { @@ -11153,7 +10748,7 @@ }, "node_modules/micromatch/node_modules/fill-range": { "version": "7.1.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "resolved": "https://registry.npmmirror.com/fill-range/-/fill-range-7.1.1.tgz", "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "license": "MIT", "dependencies": { @@ -11165,7 +10760,7 @@ }, "node_modules/micromatch/node_modules/is-number": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "license": "MIT", "engines": { @@ -11174,7 +10769,7 @@ }, "node_modules/micromatch/node_modules/to-regex-range": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "license": "MIT", "dependencies": { @@ -11186,7 +10781,7 @@ }, "node_modules/mime-db": { "version": "1.52.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "resolved": "https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz", "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", "dev": true, "license": "MIT", @@ -11196,7 +10791,7 @@ }, "node_modules/mime-types": { "version": "2.1.35", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "resolved": "https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz", "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", "dev": true, "license": "MIT", @@ -11209,7 +10804,7 @@ }, "node_modules/mimic-fn": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/mimic-fn/-/mimic-fn-2.1.0.tgz", "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", "dev": true, "license": "MIT", @@ -11219,7 +10814,7 @@ }, "node_modules/mimic-function": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/mimic-function/-/mimic-function-5.0.1.tgz", "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==", "dev": true, "license": "MIT", @@ -11232,7 +10827,7 @@ }, "node_modules/mimic-response": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/mimic-response/-/mimic-response-3.1.0.tgz", "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", "dev": true, "license": "MIT", @@ -11245,7 +10840,7 @@ }, "node_modules/minimatch": { "version": "3.1.5", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-3.1.5.tgz", "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", "dev": true, "license": "ISC", @@ -11258,7 +10853,7 @@ }, "node_modules/minimist": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "resolved": "https://registry.npmmirror.com/minimist/-/minimist-1.2.8.tgz", "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true, "license": "MIT", @@ -11268,7 +10863,7 @@ }, "node_modules/mixin-deep": { "version": "1.3.2", - "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", + "resolved": "https://registry.npmmirror.com/mixin-deep/-/mixin-deep-1.3.2.tgz", "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", "dev": true, "license": "MIT", @@ -11282,7 +10877,7 @@ }, "node_modules/mixin-deep/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -11295,7 +10890,7 @@ }, "node_modules/mixin-deep/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -11308,7 +10903,7 @@ }, "node_modules/mkdirp": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/mkdirp/-/mkdirp-3.0.1.tgz", "integrity": "sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==", "dev": true, "license": "MIT", @@ -11324,14 +10919,14 @@ }, "node_modules/mkdirp-classic": { "version": "0.5.3", - "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", + "resolved": "https://registry.npmmirror.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", "dev": true, "license": "MIT" }, "node_modules/mocha": { "version": "8.4.0", - "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.4.0.tgz", + "resolved": "https://registry.npmmirror.com/mocha/-/mocha-8.4.0.tgz", "integrity": "sha512-hJaO0mwDXmZS4ghXsvPVriOhsxQ7ofcpQdm8dE+jISUOKopitvnXFQmpRR7jd2K6VBG6E26gU3IAbXXGIbu4sQ==", "dev": true, "license": "MIT", @@ -11376,7 +10971,7 @@ }, "node_modules/mocha/node_modules/ansi-colors": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-colors/-/ansi-colors-4.1.1.tgz", "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", "dev": true, "license": "MIT", @@ -11386,7 +10981,7 @@ }, "node_modules/mocha/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -11402,7 +10997,7 @@ }, "node_modules/mocha/node_modules/anymatch": { "version": "3.1.3", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "resolved": "https://registry.npmmirror.com/anymatch/-/anymatch-3.1.3.tgz", "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", "dev": true, "license": "ISC", @@ -11416,7 +11011,7 @@ }, "node_modules/mocha/node_modules/binary-extensions": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "resolved": "https://registry.npmmirror.com/binary-extensions/-/binary-extensions-2.3.0.tgz", "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", "dev": true, "license": "MIT", @@ -11429,7 +11024,7 @@ }, "node_modules/mocha/node_modules/braces": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "resolved": "https://registry.npmmirror.com/braces/-/braces-3.0.3.tgz", "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", "dev": true, "license": "MIT", @@ -11442,7 +11037,7 @@ }, "node_modules/mocha/node_modules/chokidar": { "version": "3.5.1", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.1.tgz", + "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-3.5.1.tgz", "integrity": "sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==", "dev": true, "license": "MIT", @@ -11464,7 +11059,7 @@ }, "node_modules/mocha/node_modules/cliui": { "version": "7.0.4", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "resolved": "https://registry.npmmirror.com/cliui/-/cliui-7.0.4.tgz", "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", "dev": true, "license": "ISC", @@ -11476,7 +11071,7 @@ }, "node_modules/mocha/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -11489,14 +11084,14 @@ }, "node_modules/mocha/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/mocha/node_modules/debug": { "version": "4.3.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-4.3.1.tgz", "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==", "dev": true, "license": "MIT", @@ -11514,14 +11109,14 @@ }, "node_modules/mocha/node_modules/debug/node_modules/ms": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", "dev": true, "license": "MIT" }, "node_modules/mocha/node_modules/escape-string-regexp": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, "license": "MIT", @@ -11534,7 +11129,7 @@ }, "node_modules/mocha/node_modules/fill-range": { "version": "7.1.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "resolved": "https://registry.npmmirror.com/fill-range/-/fill-range-7.1.1.tgz", "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "dev": true, "license": "MIT", @@ -11547,7 +11142,7 @@ }, "node_modules/mocha/node_modules/fsevents": { "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", "dev": true, "hasInstallScript": true, @@ -11562,7 +11157,7 @@ }, "node_modules/mocha/node_modules/get-caller-file": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true, "license": "ISC", @@ -11572,7 +11167,7 @@ }, "node_modules/mocha/node_modules/glob-parent": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, "license": "ISC", @@ -11585,7 +11180,7 @@ }, "node_modules/mocha/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -11595,7 +11190,7 @@ }, "node_modules/mocha/node_modules/is-binary-path": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dev": true, "license": "MIT", @@ -11608,7 +11203,7 @@ }, "node_modules/mocha/node_modules/is-number": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, "license": "MIT", @@ -11618,7 +11213,7 @@ }, "node_modules/mocha/node_modules/js-yaml": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/js-yaml/-/js-yaml-4.0.0.tgz", "integrity": "sha512-pqon0s+4ScYUvX30wxQi3PogGFAlUyH0awepWvwkj4jD4v+ova3RiYw8bmA6x2rDrEaj8i/oWKoRxpVNW+Re8Q==", "dev": true, "license": "MIT", @@ -11631,7 +11226,7 @@ }, "node_modules/mocha/node_modules/minimatch": { "version": "3.0.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-3.0.4.tgz", "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", "dev": true, "license": "ISC", @@ -11644,7 +11239,7 @@ }, "node_modules/mocha/node_modules/readdirp": { "version": "3.5.0", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.5.0.tgz", + "resolved": "https://registry.npmmirror.com/readdirp/-/readdirp-3.5.0.tgz", "integrity": "sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==", "dev": true, "license": "MIT", @@ -11657,7 +11252,7 @@ }, "node_modules/mocha/node_modules/supports-color": { "version": "8.1.1", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-8.1.1.tgz", "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "license": "MIT", @@ -11673,7 +11268,7 @@ }, "node_modules/mocha/node_modules/to-regex-range": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "license": "MIT", @@ -11686,7 +11281,7 @@ }, "node_modules/mocha/node_modules/wrap-ansi": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, "license": "MIT", @@ -11704,7 +11299,7 @@ }, "node_modules/mocha/node_modules/y18n": { "version": "5.0.8", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "resolved": "https://registry.npmmirror.com/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true, "license": "ISC", @@ -11714,7 +11309,7 @@ }, "node_modules/mocha/node_modules/yargs": { "version": "16.2.0", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "resolved": "https://registry.npmmirror.com/yargs/-/yargs-16.2.0.tgz", "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", "dev": true, "license": "MIT", @@ -11733,13 +11328,13 @@ }, "node_modules/ms": { "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "license": "MIT" }, "node_modules/multi-stage-sourcemap": { "version": "0.3.1", - "resolved": "https://registry.npmjs.org/multi-stage-sourcemap/-/multi-stage-sourcemap-0.3.1.tgz", + "resolved": "https://registry.npmmirror.com/multi-stage-sourcemap/-/multi-stage-sourcemap-0.3.1.tgz", "integrity": "sha512-UiTLYjqeIoVnJHyWGskwMKIhtZKK9uXUjSTWuwatarrc0d2H/6MAVFdwvEA/aKOHamIn7z4tfvxjz+FYucFpNQ==", "dev": true, "license": "MIT", @@ -11749,7 +11344,7 @@ }, "node_modules/multi-stage-sourcemap/node_modules/source-map": { "version": "0.1.43", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz", + "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.1.43.tgz", "integrity": "sha512-VtCvB9SIQhk3aF6h+N85EaqIaBFIAfZ9Cu+NJHHVvc8BbEcnvDcFw6sqQ2dQrT6SlOrZq3tIvyD9+EGq/lJryQ==", "dev": true, "dependencies": { @@ -11761,7 +11356,7 @@ }, "node_modules/multimatch": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/multimatch/-/multimatch-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/multimatch/-/multimatch-5.0.0.tgz", "integrity": "sha512-ypMKuglUrZUD99Tk2bUQ+xNQj43lPEfAeX2o9cTteAmShXy2VHDJpuwu1o0xqoKCt9jLVAvwyFKdLTPXKAfJyA==", "dev": true, "license": "MIT", @@ -11781,7 +11376,7 @@ }, "node_modules/multistream": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/multistream/-/multistream-4.1.0.tgz", + "resolved": "https://registry.npmmirror.com/multistream/-/multistream-4.1.0.tgz", "integrity": "sha512-J1XDiAmmNpRCBfIWJv+n0ymC4ABcf/Pl+5YvC5B/D2f/2+8PtHvCNxMPKiQcZyi922Hq69J2YOpb1pTywfifyw==", "dev": true, "funding": [ @@ -11806,7 +11401,7 @@ }, "node_modules/multistream/node_modules/readable-stream": { "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "resolved": "https://registry.npmmirror.com/readable-stream/-/readable-stream-3.6.2.tgz", "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "dev": true, "license": "MIT", @@ -11821,7 +11416,7 @@ }, "node_modules/mute-stdout": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/mute-stdout/-/mute-stdout-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/mute-stdout/-/mute-stdout-1.0.1.tgz", "integrity": "sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==", "dev": true, "license": "MIT", @@ -11831,7 +11426,7 @@ }, "node_modules/nan": { "version": "2.26.2", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.26.2.tgz", + "resolved": "https://registry.npmmirror.com/nan/-/nan-2.26.2.tgz", "integrity": "sha512-0tTvBTYkt3tdGw22nrAy50x7gpbGCCFH3AFcyS5WiUu7Eu4vWlri1woE6qHBSfy11vksDqkiwjOnlR7WV8G1Hw==", "dev": true, "license": "MIT", @@ -11839,7 +11434,7 @@ }, "node_modules/nanoid": { "version": "3.1.20", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.20.tgz", + "resolved": "https://registry.npmmirror.com/nanoid/-/nanoid-3.1.20.tgz", "integrity": "sha512-a1cQNyczgKbLX9jwbS/+d7W8fX/RfgYR7lVWwWOGIPNgK2m0MWvrGF6/m4kk6U3QcFMnZf3RIhL0v2Jgh/0Uxw==", "dev": true, "license": "MIT", @@ -11852,7 +11447,7 @@ }, "node_modules/nanomatch": { "version": "1.2.13", - "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", + "resolved": "https://registry.npmmirror.com/nanomatch/-/nanomatch-1.2.13.tgz", "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", "dev": true, "license": "MIT", @@ -11875,7 +11470,7 @@ }, "node_modules/nanomatch/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -11889,7 +11484,7 @@ }, "node_modules/nanomatch/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -11903,7 +11498,7 @@ }, "node_modules/nanomatch/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -11917,7 +11512,7 @@ }, "node_modules/nanomatch/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -11930,7 +11525,7 @@ }, "node_modules/nanomatch/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -11943,7 +11538,7 @@ }, "node_modules/nanomatch/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -11953,42 +11548,42 @@ }, "node_modules/napi-build-utils": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/napi-build-utils/-/napi-build-utils-1.0.2.tgz", "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==", "dev": true, "license": "MIT" }, "node_modules/natural-compare": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/natural-compare/-/natural-compare-1.4.0.tgz", "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", "dev": true, "license": "MIT" }, "node_modules/natural-compare-lite": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", "dev": true, "license": "MIT" }, "node_modules/neo-async": { "version": "2.6.2", - "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "resolved": "https://registry.npmmirror.com/neo-async/-/neo-async-2.6.2.tgz", "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", "dev": true, "license": "MIT" }, "node_modules/next-tick": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/next-tick/-/next-tick-1.1.0.tgz", "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==", "dev": true, "license": "ISC" }, "node_modules/node-abi": { "version": "3.89.0", - "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.89.0.tgz", + "resolved": "https://registry.npmmirror.com/node-abi/-/node-abi-3.89.0.tgz", "integrity": "sha512-6u9UwL0HlAl21+agMN3YAMXcKByMqwGx+pq+P76vii5f7hTPtKDp08/H9py6DY+cfDw7kQNTGEj/rly3IgbNQA==", "dev": true, "license": "MIT", @@ -11999,9 +11594,18 @@ "node": ">=10" } }, + "node_modules/node-addon-api": { + "version": "8.7.0", + "resolved": "https://registry.npmmirror.com/node-addon-api/-/node-addon-api-8.7.0.tgz", + "integrity": "sha512-9MdFxmkKaOYVTV+XVRG8ArDwwQ77XIgIPyKASB1k3JPq3M8fGQQQE3YpMOrKm6g//Ktx8ivZr8xo1Qmtqub+GA==", + "license": "MIT", + "engines": { + "node": "^18 || ^20 || >= 21" + } + }, "node_modules/node-exports-info": { "version": "1.6.0", - "resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.0.tgz", + "resolved": "https://registry.npmmirror.com/node-exports-info/-/node-exports-info-1.6.0.tgz", "integrity": "sha512-pyFS63ptit/P5WqUkt+UUfe+4oevH+bFeIiPPdfb0pFeYEu/1ELnJu5l+5EcTKYL5M7zaAa7S8ddywgXypqKCw==", "dev": true, "license": "MIT", @@ -12020,7 +11624,7 @@ }, "node_modules/node-exports-info/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, "license": "ISC", @@ -12030,7 +11634,7 @@ }, "node_modules/node-fetch": { "version": "2.7.0", - "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "resolved": "https://registry.npmmirror.com/node-fetch/-/node-fetch-2.7.0.tgz", "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", "license": "MIT", "dependencies": { @@ -12048,15 +11652,26 @@ } } }, + "node_modules/node-gyp-build": { + "version": "4.8.4", + "resolved": "https://registry.npmmirror.com/node-gyp-build/-/node-gyp-build-4.8.4.tgz", + "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==", + "license": "MIT", + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, "node_modules/node-releases": { "version": "2.0.37", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz", + "resolved": "https://registry.npmmirror.com/node-releases/-/node-releases-2.0.37.tgz", "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==", "license": "MIT" }, "node_modules/node-sarif-builder": { "version": "3.4.0", - "resolved": "https://registry.npmjs.org/node-sarif-builder/-/node-sarif-builder-3.4.0.tgz", + "resolved": "https://registry.npmmirror.com/node-sarif-builder/-/node-sarif-builder-3.4.0.tgz", "integrity": "sha512-tGnJW6OKRii9u/b2WiUViTJS+h7Apxx17qsMUjsUeNDiMMX5ZFf8F8Fcz7PAQ6omvOxHZtvDTmOYKJQwmfpjeg==", "dev": true, "license": "MIT", @@ -12070,7 +11685,7 @@ }, "node_modules/node-sarif-builder/node_modules/fs-extra": { "version": "11.3.4", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-11.3.4.tgz", "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "dev": true, "license": "MIT", @@ -12085,7 +11700,7 @@ }, "node_modules/node-sarif-builder/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -12098,7 +11713,7 @@ }, "node_modules/node-sarif-builder/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -12108,7 +11723,7 @@ }, "node_modules/node-uuid": { "version": "1.4.8", - "resolved": "https://registry.npmjs.org/node-uuid/-/node-uuid-1.4.8.tgz", + "resolved": "https://registry.npmmirror.com/node-uuid/-/node-uuid-1.4.8.tgz", "integrity": "sha512-TkCET/3rr9mUuRp+CpO7qfgT++aAxfDRaalQhwPFzI9BY/2rCDn6OfpZOVggi1AXfTPpfkTrg5f5WQx5G1uLxA==", "deprecated": "Use uuid module instead", "bin": { @@ -12117,7 +11732,7 @@ }, "node_modules/normalize-package-data": { "version": "2.5.0", - "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", + "resolved": "https://registry.npmmirror.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz", "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", "dev": true, "license": "BSD-2-Clause", @@ -12130,7 +11745,7 @@ }, "node_modules/normalize-package-data/node_modules/semver": { "version": "5.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-5.7.2.tgz", "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", "dev": true, "license": "ISC", @@ -12140,7 +11755,7 @@ }, "node_modules/normalize-path": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", "dev": true, "license": "MIT", @@ -12150,7 +11765,7 @@ }, "node_modules/now-and-later": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/now-and-later/-/now-and-later-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/now-and-later/-/now-and-later-2.0.1.tgz", "integrity": "sha512-KGvQ0cB70AQfg107Xvs/Fbu+dGmZoTRJp2TaPwcwQm3/7PteUyN2BCgk8KBMPGBUXZdVwyWS8fDCGFygBm19UQ==", "dev": true, "license": "MIT", @@ -12163,7 +11778,7 @@ }, "node_modules/npm-run-path": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "resolved": "https://registry.npmmirror.com/npm-run-path/-/npm-run-path-4.0.1.tgz", "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", "dev": true, "license": "MIT", @@ -12176,7 +11791,7 @@ }, "node_modules/number-is-nan": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/number-is-nan/-/number-is-nan-1.0.1.tgz", "integrity": "sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==", "dev": true, "license": "MIT", @@ -12186,14 +11801,14 @@ }, "node_modules/o-stream": { "version": "0.3.0", - "resolved": "https://registry.npmjs.org/o-stream/-/o-stream-0.3.0.tgz", + "resolved": "https://registry.npmmirror.com/o-stream/-/o-stream-0.3.0.tgz", "integrity": "sha512-gbzl6qCJZ609x/M2t25HqCYQagFzWYCtQ84jcuObGr+V8D1Am4EVubkF4J+XFs6ukfiv96vNeiBb8FrbbMZYiQ==", "dev": true, "license": "MIT" }, "node_modules/object-assign": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "resolved": "https://registry.npmmirror.com/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", "dev": true, "license": "MIT", @@ -12203,7 +11818,7 @@ }, "node_modules/object-copy": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", + "resolved": "https://registry.npmmirror.com/object-copy/-/object-copy-0.1.0.tgz", "integrity": "sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ==", "dev": true, "license": "MIT", @@ -12218,7 +11833,7 @@ }, "node_modules/object-copy/node_modules/kind-of": { "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==", "dev": true, "license": "MIT", @@ -12231,7 +11846,7 @@ }, "node_modules/object-inspect": { "version": "1.13.4", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "resolved": "https://registry.npmmirror.com/object-inspect/-/object-inspect-1.13.4.tgz", "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", "dev": true, "license": "MIT", @@ -12244,7 +11859,7 @@ }, "node_modules/object-is": { "version": "1.1.6", - "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz", + "resolved": "https://registry.npmmirror.com/object-is/-/object-is-1.1.6.tgz", "integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==", "dev": true, "license": "MIT", @@ -12261,7 +11876,7 @@ }, "node_modules/object-keys": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/object-keys/-/object-keys-1.1.1.tgz", "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", "dev": true, "license": "MIT", @@ -12271,7 +11886,7 @@ }, "node_modules/object-visit": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/object-visit/-/object-visit-1.0.1.tgz", "integrity": "sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA==", "dev": true, "license": "MIT", @@ -12284,7 +11899,7 @@ }, "node_modules/object.assign": { "version": "4.1.7", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz", + "resolved": "https://registry.npmmirror.com/object.assign/-/object.assign-4.1.7.tgz", "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", "dev": true, "license": "MIT", @@ -12305,7 +11920,7 @@ }, "node_modules/object.defaults": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/object.defaults/-/object.defaults-1.1.0.tgz", "integrity": "sha512-c/K0mw/F11k4dEUBMW8naXUuBuhxRCfG7W+yFy8EcijU/rSmazOUd1XAEEe6bC0OuXY4HUKjTJv7xbxIMqdxrA==", "dev": true, "license": "MIT", @@ -12321,7 +11936,7 @@ }, "node_modules/object.entries": { "version": "1.1.9", - "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.9.tgz", + "resolved": "https://registry.npmmirror.com/object.entries/-/object.entries-1.1.9.tgz", "integrity": "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==", "dev": true, "license": "MIT", @@ -12337,7 +11952,7 @@ }, "node_modules/object.fromentries": { "version": "2.0.8", - "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz", + "resolved": "https://registry.npmmirror.com/object.fromentries/-/object.fromentries-2.0.8.tgz", "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==", "dev": true, "license": "MIT", @@ -12356,7 +11971,7 @@ }, "node_modules/object.groupby": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/object.groupby/-/object.groupby-1.0.3.tgz", "integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==", "dev": true, "license": "MIT", @@ -12371,7 +11986,7 @@ }, "node_modules/object.map": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/object.map/-/object.map-1.0.1.tgz", "integrity": "sha512-3+mAJu2PLfnSVGHwIWubpOFLscJANBKuB/6A4CxBstc4aqwQY0FWcsppuy4jU5GSB95yES5JHSI+33AWuS4k6w==", "dev": true, "license": "MIT", @@ -12385,7 +12000,7 @@ }, "node_modules/object.pick": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/object.pick/-/object.pick-1.3.0.tgz", "integrity": "sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==", "dev": true, "license": "MIT", @@ -12398,7 +12013,7 @@ }, "node_modules/object.reduce": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.reduce/-/object.reduce-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/object.reduce/-/object.reduce-1.0.1.tgz", "integrity": "sha512-naLhxxpUESbNkRqc35oQ2scZSJueHGQNUfMW/0U37IgN6tE2dgDWg3whf+NEliy3F/QysrO48XKUz/nGPe+AQw==", "dev": true, "license": "MIT", @@ -12412,7 +12027,7 @@ }, "node_modules/object.values": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/object.values/-/object.values-1.2.1.tgz", "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==", "dev": true, "license": "MIT", @@ -12431,7 +12046,7 @@ }, "node_modules/once": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/once/-/once-1.4.0.tgz", "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", "dev": true, "license": "ISC", @@ -12441,7 +12056,7 @@ }, "node_modules/onetime": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "resolved": "https://registry.npmmirror.com/onetime/-/onetime-5.1.2.tgz", "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", "dev": true, "license": "MIT", @@ -12457,7 +12072,7 @@ }, "node_modules/optionator": { "version": "0.9.4", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "resolved": "https://registry.npmmirror.com/optionator/-/optionator-0.9.4.tgz", "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", "dev": true, "license": "MIT", @@ -12475,7 +12090,7 @@ }, "node_modules/ordered-read-streams": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz", "integrity": "sha512-Z87aSjx3r5c0ZB7bcJqIgIRX5bxR7A4aSzvIbaxd0oTkWBCOoKfuGHiKj60CHVUgg1Phm5yMZzBdt8XqRs73Mw==", "dev": true, "license": "MIT", @@ -12485,7 +12100,7 @@ }, "node_modules/os-locale": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", + "resolved": "https://registry.npmmirror.com/os-locale/-/os-locale-1.4.0.tgz", "integrity": "sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==", "dev": true, "license": "MIT", @@ -12498,7 +12113,7 @@ }, "node_modules/own-keys": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/own-keys/-/own-keys-1.0.1.tgz", "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==", "dev": true, "license": "MIT", @@ -12516,7 +12131,7 @@ }, "node_modules/p-is-promise": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/p-is-promise/-/p-is-promise-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/p-is-promise/-/p-is-promise-3.0.0.tgz", "integrity": "sha512-Wo8VsW4IRQSKVXsJCn7TomUaVtyfjVDn3nUP7kE967BQk0CwFpdbZs0X0uk5sW9mkBa9eNM7hCMaG93WUAwxYQ==", "dev": true, "license": "MIT", @@ -12526,7 +12141,7 @@ }, "node_modules/p-limit": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-3.1.0.tgz", "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "license": "MIT", @@ -12542,7 +12157,7 @@ }, "node_modules/p-locate": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/p-locate/-/p-locate-5.0.0.tgz", "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "license": "MIT", @@ -12558,7 +12173,7 @@ }, "node_modules/parent-module": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/parent-module/-/parent-module-1.0.1.tgz", "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", "dev": true, "license": "MIT", @@ -12571,7 +12186,7 @@ }, "node_modules/parse-filepath": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/parse-filepath/-/parse-filepath-1.0.2.tgz", "integrity": "sha512-FwdRXKCohSVeXqwtYonZTXtbGJKrn+HNyWDYVcp5yuJlesTwNH4rsmRZ+GrKAPJ5bLpRxESMeS+Rl0VCHRvB2Q==", "dev": true, "license": "MIT", @@ -12586,7 +12201,7 @@ }, "node_modules/parse-imports-exports": { "version": "0.2.4", - "resolved": "https://registry.npmjs.org/parse-imports-exports/-/parse-imports-exports-0.2.4.tgz", + "resolved": "https://registry.npmmirror.com/parse-imports-exports/-/parse-imports-exports-0.2.4.tgz", "integrity": "sha512-4s6vd6dx1AotCx/RCI2m7t7GCh5bDRUtGNvRfHSP2wbBQdMi67pPe7mtzmgwcaQ8VKK/6IB7Glfyu3qdZJPybQ==", "dev": true, "license": "MIT", @@ -12596,7 +12211,7 @@ }, "node_modules/parse-json": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "resolved": "https://registry.npmmirror.com/parse-json/-/parse-json-2.2.0.tgz", "integrity": "sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==", "dev": true, "license": "MIT", @@ -12609,7 +12224,7 @@ }, "node_modules/parse-node-version": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parse-node-version/-/parse-node-version-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/parse-node-version/-/parse-node-version-1.0.1.tgz", "integrity": "sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==", "dev": true, "license": "MIT", @@ -12619,7 +12234,7 @@ }, "node_modules/parse-passwd": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/parse-passwd/-/parse-passwd-1.0.0.tgz", "integrity": "sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==", "dev": true, "license": "MIT", @@ -12629,14 +12244,14 @@ }, "node_modules/parse-statements": { "version": "1.0.11", - "resolved": "https://registry.npmjs.org/parse-statements/-/parse-statements-1.0.11.tgz", + "resolved": "https://registry.npmmirror.com/parse-statements/-/parse-statements-1.0.11.tgz", "integrity": "sha512-HlsyYdMBnbPQ9Jr/VgJ1YF4scnldvJpJxCVx6KgqPL4dxppsWrJHCIIxQXMJrqGnsRkNPATbeMJ8Yxu7JMsYcA==", "dev": true, "license": "MIT" }, "node_modules/pascalcase": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/pascalcase/-/pascalcase-0.1.1.tgz", "integrity": "sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw==", "dev": true, "license": "MIT", @@ -12646,14 +12261,14 @@ }, "node_modules/path-dirname": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/path-dirname/-/path-dirname-1.0.2.tgz", "integrity": "sha512-ALzNPpyNq9AqXMBjeymIjFDAkAFH06mHJH/cSBHAgU0s4vfpBn6b2nf8tiRLvagKD8RbTpq2FKTBg7cl9l3c7Q==", "dev": true, "license": "MIT" }, "node_modules/path-exists": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz", "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true, "license": "MIT", @@ -12663,13 +12278,13 @@ }, "node_modules/path-extra": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/path-extra/-/path-extra-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/path-extra/-/path-extra-1.0.3.tgz", "integrity": "sha512-vYm3+GCkjUlT1rDvZnDVhNLXIRvwFPaN8ebHAFcuMJM/H0RBOPD7JrcldiNLd9AS3dhAyUHLa4Hny5wp1A+Ffw==", "license": "MIT" }, "node_modules/path-is-absolute": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", "dev": true, "license": "MIT", @@ -12679,7 +12294,7 @@ }, "node_modules/path-key": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "resolved": "https://registry.npmmirror.com/path-key/-/path-key-3.1.1.tgz", "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", "dev": true, "license": "MIT", @@ -12689,13 +12304,13 @@ }, "node_modules/path-parse": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "resolved": "https://registry.npmmirror.com/path-parse/-/path-parse-1.0.7.tgz", "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "license": "MIT" }, "node_modules/path-root": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/path-root/-/path-root-0.1.1.tgz", "integrity": "sha512-QLcPegTHF11axjfojBIoDygmS2E3Lf+8+jI6wOVmNVenrKSo3mFdSGiIgdSHenczw3wPtlVMQaFVwGmM7BJdtg==", "dev": true, "license": "MIT", @@ -12708,7 +12323,7 @@ }, "node_modules/path-root-regex": { "version": "0.1.2", - "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz", + "resolved": "https://registry.npmmirror.com/path-root-regex/-/path-root-regex-0.1.2.tgz", "integrity": "sha512-4GlJ6rZDhQZFE0DPVKh0e9jmZ5egZfxTkp7bcRDuPlJXbAwhxcl2dINPUAsjLdejqaLsCeg8axcLjIbvBjN4pQ==", "dev": true, "license": "MIT", @@ -12718,7 +12333,7 @@ }, "node_modules/path-type": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/path-type/-/path-type-4.0.0.tgz", "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", "dev": true, "license": "MIT", @@ -12728,7 +12343,7 @@ }, "node_modules/pathval": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/pathval/-/pathval-1.1.1.tgz", "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", "dev": true, "license": "MIT", @@ -12738,13 +12353,13 @@ }, "node_modules/picocolors": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/picocolors/-/picocolors-1.1.1.tgz", "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", "license": "ISC" }, "node_modules/picomatch": { "version": "2.3.2", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-2.3.2.tgz", "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", "license": "MIT", "engines": { @@ -12756,7 +12371,7 @@ }, "node_modules/pify": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "resolved": "https://registry.npmmirror.com/pify/-/pify-2.3.0.tgz", "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", "dev": true, "license": "MIT", @@ -12766,7 +12381,7 @@ }, "node_modules/pinkie": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/pinkie/-/pinkie-2.0.4.tgz", "integrity": "sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==", "dev": true, "license": "MIT", @@ -12776,7 +12391,7 @@ }, "node_modules/pinkie-promise": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz", "integrity": "sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==", "dev": true, "license": "MIT", @@ -12789,7 +12404,7 @@ }, "node_modules/pkg": { "version": "5.8.1", - "resolved": "https://registry.npmjs.org/pkg/-/pkg-5.8.1.tgz", + "resolved": "https://registry.npmmirror.com/pkg/-/pkg-5.8.1.tgz", "integrity": "sha512-CjBWtFStCfIiT4Bde9QpJy0KeH19jCfwZRJqHFDFXfhUklCx8JoFmMj3wgnEYIwGmZVNkhsStPHEOnrtrQhEXA==", "dev": true, "license": "MIT", @@ -12823,7 +12438,7 @@ }, "node_modules/pkg-fetch": { "version": "3.4.2", - "resolved": "https://registry.npmjs.org/pkg-fetch/-/pkg-fetch-3.4.2.tgz", + "resolved": "https://registry.npmmirror.com/pkg-fetch/-/pkg-fetch-3.4.2.tgz", "integrity": "sha512-0+uijmzYcnhC0hStDjm/cl2VYdrmVVBpe7Q8k9YBojxmR5tG8mvR9/nooQq3QSXiQqORDVOTY3XqMEqJVIzkHA==", "dev": true, "license": "MIT", @@ -12843,7 +12458,7 @@ }, "node_modules/pkg-fetch/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -12859,7 +12474,7 @@ }, "node_modules/pkg-fetch/node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", @@ -12876,7 +12491,7 @@ }, "node_modules/pkg-fetch/node_modules/cliui": { "version": "7.0.4", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "resolved": "https://registry.npmmirror.com/cliui/-/cliui-7.0.4.tgz", "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", "dev": true, "license": "ISC", @@ -12888,7 +12503,7 @@ }, "node_modules/pkg-fetch/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -12901,14 +12516,14 @@ }, "node_modules/pkg-fetch/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/pkg-fetch/node_modules/fs-extra": { "version": "9.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-9.1.0.tgz", "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", "dev": true, "license": "MIT", @@ -12924,7 +12539,7 @@ }, "node_modules/pkg-fetch/node_modules/get-caller-file": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true, "license": "ISC", @@ -12934,7 +12549,7 @@ }, "node_modules/pkg-fetch/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -12944,7 +12559,7 @@ }, "node_modules/pkg-fetch/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -12957,7 +12572,7 @@ }, "node_modules/pkg-fetch/node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "license": "MIT", @@ -12970,7 +12585,7 @@ }, "node_modules/pkg-fetch/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -12980,7 +12595,7 @@ }, "node_modules/pkg-fetch/node_modules/wrap-ansi": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, "license": "MIT", @@ -12998,7 +12613,7 @@ }, "node_modules/pkg-fetch/node_modules/y18n": { "version": "5.0.8", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "resolved": "https://registry.npmmirror.com/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true, "license": "ISC", @@ -13008,7 +12623,7 @@ }, "node_modules/pkg-fetch/node_modules/yargs": { "version": "16.2.0", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "resolved": "https://registry.npmmirror.com/yargs/-/yargs-16.2.0.tgz", "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", "dev": true, "license": "MIT", @@ -13027,7 +12642,7 @@ }, "node_modules/pkg/node_modules/@babel/generator": { "version": "7.18.2", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.2.tgz", + "resolved": "https://registry.npmmirror.com/@babel/generator/-/generator-7.18.2.tgz", "integrity": "sha512-W1lG5vUwFvfMd8HVXqdfbuG7RuaSrTCCD8cl8fP8wOivdbtbIg2Db3IWUcgvfxKbbn6ZBGYRW/Zk1MIwK49mgw==", "dev": true, "license": "MIT", @@ -13042,7 +12657,7 @@ }, "node_modules/pkg/node_modules/@babel/parser": { "version": "7.18.4", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.4.tgz", + "resolved": "https://registry.npmmirror.com/@babel/parser/-/parser-7.18.4.tgz", "integrity": "sha512-FDge0dFazETFcxGw/EXzOkN8uJp0PC7Qbm+Pe9T+av2zlBpOgunFHkQPPn+eRuClU73JF+98D531UgayY89tow==", "dev": true, "license": "MIT", @@ -13055,7 +12670,7 @@ }, "node_modules/pkg/node_modules/@babel/types": { "version": "7.19.0", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.19.0.tgz", + "resolved": "https://registry.npmmirror.com/@babel/types/-/types-7.19.0.tgz", "integrity": "sha512-YuGopBq3ke25BVSiS6fgF49Ul9gH1x70Bcr6bqRLjWCkcX8Hre1/5+z+IiWOIerRMSSEfGZVB9z9kyq7wVs9YA==", "dev": true, "license": "MIT", @@ -13070,7 +12685,7 @@ }, "node_modules/pkg/node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", @@ -13086,7 +12701,7 @@ }, "node_modules/pkg/node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", @@ -13103,7 +12718,7 @@ }, "node_modules/pkg/node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "license": "MIT", @@ -13116,14 +12731,14 @@ }, "node_modules/pkg/node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true, "license": "MIT" }, "node_modules/pkg/node_modules/fs-extra": { "version": "9.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-9.1.0.tgz", "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", "dev": true, "license": "MIT", @@ -13139,7 +12754,7 @@ }, "node_modules/pkg/node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "license": "MIT", @@ -13149,7 +12764,7 @@ }, "node_modules/pkg/node_modules/is-core-module": { "version": "2.9.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", + "resolved": "https://registry.npmmirror.com/is-core-module/-/is-core-module-2.9.0.tgz", "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==", "dev": true, "license": "MIT", @@ -13162,7 +12777,7 @@ }, "node_modules/pkg/node_modules/jsesc": { "version": "2.5.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "resolved": "https://registry.npmmirror.com/jsesc/-/jsesc-2.5.2.tgz", "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", "dev": true, "license": "MIT", @@ -13175,7 +12790,7 @@ }, "node_modules/pkg/node_modules/jsonfile": { "version": "6.2.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-6.2.0.tgz", "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "dev": true, "license": "MIT", @@ -13188,7 +12803,7 @@ }, "node_modules/pkg/node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "license": "MIT", @@ -13201,7 +12816,7 @@ }, "node_modules/pkg/node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-2.0.1.tgz", "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", "dev": true, "license": "MIT", @@ -13211,7 +12826,7 @@ }, "node_modules/plugin-error": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/plugin-error/-/plugin-error-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/plugin-error/-/plugin-error-1.0.1.tgz", "integrity": "sha512-L1zP0dk7vGweZME2i+EeakvUNqSrdiI3F91TwEoYiGrAfUXmVv6fJIq4g82PAXxNsWOp0J7ZqQy/3Szz0ajTxA==", "dev": true, "license": "MIT", @@ -13227,7 +12842,7 @@ }, "node_modules/plugin-error/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -13241,7 +12856,7 @@ }, "node_modules/plugin-error/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -13254,7 +12869,7 @@ }, "node_modules/plugin-error/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -13267,7 +12882,7 @@ }, "node_modules/posix-character-classes": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", + "resolved": "https://registry.npmmirror.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz", "integrity": "sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg==", "dev": true, "license": "MIT", @@ -13277,7 +12892,7 @@ }, "node_modules/possible-typed-array-names": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", "dev": true, "license": "MIT", @@ -13287,9 +12902,8 @@ }, "node_modules/prebuild-install": { "version": "7.1.1", - "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.1.tgz", + "resolved": "https://registry.npmmirror.com/prebuild-install/-/prebuild-install-7.1.1.tgz", "integrity": "sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw==", - "deprecated": "No longer maintained. Please contact the author of the relevant native addon; alternatives are available.", "dev": true, "license": "MIT", "dependencies": { @@ -13315,7 +12929,7 @@ }, "node_modules/prelude-ls": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/prelude-ls/-/prelude-ls-1.2.1.tgz", "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", "dev": true, "license": "MIT", @@ -13325,7 +12939,7 @@ }, "node_modules/prettier": { "version": "3.8.1", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz", + "resolved": "https://registry.npmmirror.com/prettier/-/prettier-3.8.1.tgz", "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==", "dev": true, "license": "MIT", @@ -13341,7 +12955,7 @@ }, "node_modules/prettier-linter-helpers": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.1.tgz", "integrity": "sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==", "dev": true, "license": "MIT", @@ -13354,7 +12968,7 @@ }, "node_modules/pretty-hrtime": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==", "dev": true, "license": "MIT", @@ -13364,7 +12978,7 @@ }, "node_modules/private": { "version": "0.1.8", - "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", + "resolved": "https://registry.npmmirror.com/private/-/private-0.1.8.tgz", "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==", "dev": true, "license": "MIT", @@ -13374,7 +12988,7 @@ }, "node_modules/process": { "version": "0.11.10", - "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "resolved": "https://registry.npmmirror.com/process/-/process-0.11.10.tgz", "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==", "dev": true, "license": "MIT", @@ -13384,14 +12998,14 @@ }, "node_modules/process-nextick-args": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz", "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", "dev": true, "license": "MIT" }, "node_modules/progress": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "resolved": "https://registry.npmmirror.com/progress/-/progress-2.0.3.tgz", "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", "dev": true, "license": "MIT", @@ -13401,7 +13015,7 @@ }, "node_modules/promise": { "version": "7.3.1", - "resolved": "https://registry.npmjs.org/promise/-/promise-7.3.1.tgz", + "resolved": "https://registry.npmmirror.com/promise/-/promise-7.3.1.tgz", "integrity": "sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg==", "dev": true, "license": "MIT", @@ -13411,7 +13025,7 @@ }, "node_modules/pug": { "version": "3.0.4", - "resolved": "https://registry.npmjs.org/pug/-/pug-3.0.4.tgz", + "resolved": "https://registry.npmmirror.com/pug/-/pug-3.0.4.tgz", "integrity": "sha512-kFfq5mMzrS7+wrl5pLJzZEzemx34OQ0w4SARfhy/3yxTlhbstsudDwJzhf1hP02yHzbjoVMSXUj/Sz6RNfMyXg==", "dev": true, "license": "MIT", @@ -13428,7 +13042,7 @@ }, "node_modules/pug-attrs": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pug-attrs/-/pug-attrs-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-attrs/-/pug-attrs-3.0.0.tgz", "integrity": "sha512-azINV9dUtzPMFQktvTXciNAfAuVh/L/JCl0vtPCwvOA21uZrC08K/UnmrL+SXGEVc1FwzjW62+xw5S/uaLj6cA==", "dev": true, "license": "MIT", @@ -13440,7 +13054,7 @@ }, "node_modules/pug-code-gen": { "version": "3.0.4", - "resolved": "https://registry.npmjs.org/pug-code-gen/-/pug-code-gen-3.0.4.tgz", + "resolved": "https://registry.npmmirror.com/pug-code-gen/-/pug-code-gen-3.0.4.tgz", "integrity": "sha512-6okWYIKdasTyXICyEtvobmTZAVX57JkzgzIi4iRJlin8kmhG+Xry2dsus+Mun/nGCn6F2U49haHI5mkELXB14g==", "dev": true, "license": "MIT", @@ -13457,14 +13071,14 @@ }, "node_modules/pug-error": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/pug-error/-/pug-error-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-error/-/pug-error-2.1.0.tgz", "integrity": "sha512-lv7sU9e5Jk8IeUheHata6/UThZ7RK2jnaaNztxfPYUY+VxZyk/ePVaNZ/vwmH8WqGvDz3LrNYt/+gA55NDg6Pg==", "dev": true, "license": "MIT" }, "node_modules/pug-filters": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/pug-filters/-/pug-filters-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-filters/-/pug-filters-4.0.0.tgz", "integrity": "sha512-yeNFtq5Yxmfz0f9z2rMXGw/8/4i1cCFecw/Q7+D0V2DdtII5UvqE12VaZ2AY7ri6o5RNXiweGH79OCq+2RQU4A==", "dev": true, "license": "MIT", @@ -13478,7 +13092,7 @@ }, "node_modules/pug-lexer": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/pug-lexer/-/pug-lexer-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/pug-lexer/-/pug-lexer-5.0.1.tgz", "integrity": "sha512-0I6C62+keXlZPZkOJeVam9aBLVP2EnbeDw3An+k0/QlqdwH6rv8284nko14Na7c0TtqtogfWXcRoFE4O4Ff20w==", "dev": true, "license": "MIT", @@ -13490,7 +13104,7 @@ }, "node_modules/pug-linker": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/pug-linker/-/pug-linker-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-linker/-/pug-linker-4.0.0.tgz", "integrity": "sha512-gjD1yzp0yxbQqnzBAdlhbgoJL5qIFJw78juN1NpTLt/mfPJ5VgC4BvkoD3G23qKzJtIIXBbcCt6FioLSFLOHdw==", "dev": true, "license": "MIT", @@ -13501,7 +13115,7 @@ }, "node_modules/pug-load": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pug-load/-/pug-load-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-load/-/pug-load-3.0.0.tgz", "integrity": "sha512-OCjTEnhLWZBvS4zni/WUMjH2YSUosnsmjGBB1An7CsKQarYSWQ0GCVyd4eQPMFJqZ8w9xgs01QdiZXKVjk92EQ==", "dev": true, "license": "MIT", @@ -13512,7 +13126,7 @@ }, "node_modules/pug-parser": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/pug-parser/-/pug-parser-6.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-parser/-/pug-parser-6.0.0.tgz", "integrity": "sha512-ukiYM/9cH6Cml+AOl5kETtM9NR3WulyVP2y4HOU45DyMim1IeP/OOiyEWRr6qk5I5klpsBnbuHpwKmTx6WURnw==", "dev": true, "license": "MIT", @@ -13523,14 +13137,14 @@ }, "node_modules/pug-runtime": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/pug-runtime/-/pug-runtime-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/pug-runtime/-/pug-runtime-3.0.1.tgz", "integrity": "sha512-L50zbvrQ35TkpHwv0G6aLSuueDRwc/97XdY8kL3tOT0FmhgG7UypU3VztfV/LATAvmUfYi4wNxSajhSAeNN+Kg==", "dev": true, "license": "MIT" }, "node_modules/pug-strip-comments": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/pug-strip-comments/-/pug-strip-comments-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-strip-comments/-/pug-strip-comments-2.0.0.tgz", "integrity": "sha512-zo8DsDpH7eTkPHCXFeAk1xZXJbyoTfdPlNR0bK7rpOMuhBYb0f5qUVCO1xlsitYd3w5FQTK7zpNVKb3rZoUrrQ==", "dev": true, "license": "MIT", @@ -13540,14 +13154,14 @@ }, "node_modules/pug-walk": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/pug-walk/-/pug-walk-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/pug-walk/-/pug-walk-2.0.0.tgz", "integrity": "sha512-yYELe9Q5q9IQhuvqsZNwA5hfPkMJ8u92bQLIMcsMxf/VADjNtEYptU+inlufAFYcWdHlwNfZOEnOOQrZrcyJCQ==", "dev": true, "license": "MIT" }, "node_modules/pump": { "version": "3.0.4", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz", + "resolved": "https://registry.npmmirror.com/pump/-/pump-3.0.4.tgz", "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==", "dev": true, "license": "MIT", @@ -13558,7 +13172,7 @@ }, "node_modules/pumpify": { "version": "1.5.1", - "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz", + "resolved": "https://registry.npmmirror.com/pumpify/-/pumpify-1.5.1.tgz", "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", "dev": true, "license": "MIT", @@ -13570,7 +13184,7 @@ }, "node_modules/pumpify/node_modules/pump": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/pump/-/pump-2.0.1.tgz", "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", "dev": true, "license": "MIT", @@ -13581,7 +13195,7 @@ }, "node_modules/punycode": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "resolved": "https://registry.npmmirror.com/punycode/-/punycode-2.3.1.tgz", "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", "dev": true, "license": "MIT", @@ -13591,7 +13205,7 @@ }, "node_modules/punycode.js": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz", + "resolved": "https://registry.npmmirror.com/punycode.js/-/punycode.js-2.3.1.tgz", "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==", "dev": true, "license": "MIT", @@ -13601,7 +13215,7 @@ }, "node_modules/queue-microtask": { "version": "1.2.3", - "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "resolved": "https://registry.npmmirror.com/queue-microtask/-/queue-microtask-1.2.3.tgz", "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", "funding": [ { @@ -13621,7 +13235,7 @@ }, "node_modules/randombytes": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/randombytes/-/randombytes-2.1.0.tgz", "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", "dev": true, "license": "MIT", @@ -13631,7 +13245,7 @@ }, "node_modules/rc": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "resolved": "https://registry.npmmirror.com/rc/-/rc-1.2.8.tgz", "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", "dev": true, "license": "(BSD-2-Clause OR MIT OR Apache-2.0)", @@ -13647,7 +13261,7 @@ }, "node_modules/rc/node_modules/strip-json-comments": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz", "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", "dev": true, "license": "MIT", @@ -13657,7 +13271,7 @@ }, "node_modules/read-pkg": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/read-pkg/-/read-pkg-1.1.0.tgz", "integrity": "sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==", "dev": true, "license": "MIT", @@ -13672,7 +13286,7 @@ }, "node_modules/read-pkg-up": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz", "integrity": "sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==", "dev": true, "license": "MIT", @@ -13686,7 +13300,7 @@ }, "node_modules/read-pkg-up/node_modules/find-up": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "resolved": "https://registry.npmmirror.com/find-up/-/find-up-1.1.2.tgz", "integrity": "sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==", "dev": true, "license": "MIT", @@ -13700,7 +13314,7 @@ }, "node_modules/read-pkg-up/node_modules/path-exists": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/path-exists/-/path-exists-2.1.0.tgz", "integrity": "sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==", "dev": true, "license": "MIT", @@ -13713,7 +13327,7 @@ }, "node_modules/read-pkg/node_modules/path-type": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/path-type/-/path-type-1.1.0.tgz", "integrity": "sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==", "dev": true, "license": "MIT", @@ -13728,7 +13342,7 @@ }, "node_modules/readable-stream": { "version": "2.3.8", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "resolved": "https://registry.npmmirror.com/readable-stream/-/readable-stream-2.3.8.tgz", "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", "dev": true, "license": "MIT", @@ -13744,14 +13358,14 @@ }, "node_modules/readable-stream/node_modules/safe-buffer": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", "dev": true, "license": "MIT" }, "node_modules/readdirp": { "version": "2.2.1", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz", + "resolved": "https://registry.npmmirror.com/readdirp/-/readdirp-2.2.1.tgz", "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==", "dev": true, "license": "MIT", @@ -13766,7 +13380,7 @@ }, "node_modules/readdirp/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -13780,7 +13394,7 @@ }, "node_modules/readdirp/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -13794,7 +13408,7 @@ }, "node_modules/readdirp/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -13808,7 +13422,7 @@ }, "node_modules/readdirp/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -13821,7 +13435,7 @@ }, "node_modules/readdirp/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -13834,7 +13448,7 @@ }, "node_modules/readdirp/node_modules/kind-of": { "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true, "license": "MIT", @@ -13844,7 +13458,7 @@ }, "node_modules/readdirp/node_modules/micromatch": { "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-3.1.10.tgz", "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "license": "MIT", @@ -13869,7 +13483,7 @@ }, "node_modules/rechoir": { "version": "0.6.2", - "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "resolved": "https://registry.npmmirror.com/rechoir/-/rechoir-0.6.2.tgz", "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", "dev": true, "dependencies": { @@ -13881,14 +13495,14 @@ }, "node_modules/reflect-metadata": { "version": "0.2.2", - "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz", + "resolved": "https://registry.npmmirror.com/reflect-metadata/-/reflect-metadata-0.2.2.tgz", "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==", "dev": true, "license": "Apache-2.0" }, "node_modules/reflect.getprototypeof": { "version": "1.0.10", - "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz", + "resolved": "https://registry.npmmirror.com/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz", "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==", "dev": true, "license": "MIT", @@ -13911,13 +13525,13 @@ }, "node_modules/regenerate": { "version": "1.4.2", - "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "resolved": "https://registry.npmmirror.com/regenerate/-/regenerate-1.4.2.tgz", "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==", "license": "MIT" }, "node_modules/regenerate-unicode-properties": { "version": "10.2.2", - "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz", + "resolved": "https://registry.npmmirror.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz", "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==", "license": "MIT", "dependencies": { @@ -13929,14 +13543,14 @@ }, "node_modules/regenerator-runtime": { "version": "0.11.1", - "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", + "resolved": "https://registry.npmmirror.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==", "dev": true, "license": "MIT" }, "node_modules/regenerator-transform": { "version": "0.10.1", - "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz", + "resolved": "https://registry.npmmirror.com/regenerator-transform/-/regenerator-transform-0.10.1.tgz", "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", "dev": true, "license": "BSD", @@ -13948,7 +13562,7 @@ }, "node_modules/regex-not": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/regex-not/-/regex-not-1.0.2.tgz", "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", "dev": true, "license": "MIT", @@ -13962,7 +13576,7 @@ }, "node_modules/regex-not/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -13976,7 +13590,7 @@ }, "node_modules/regex-not/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -13989,7 +13603,7 @@ }, "node_modules/regex-not/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -14002,7 +13616,7 @@ }, "node_modules/regexp.prototype.flags": { "version": "1.5.4", - "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz", + "resolved": "https://registry.npmmirror.com/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz", "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==", "dev": true, "license": "MIT", @@ -14023,7 +13637,7 @@ }, "node_modules/regexpu-core": { "version": "6.4.0", - "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz", + "resolved": "https://registry.npmmirror.com/regexpu-core/-/regexpu-core-6.4.0.tgz", "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==", "license": "MIT", "dependencies": { @@ -14040,14 +13654,14 @@ }, "node_modules/regjsgen": { "version": "0.8.0", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz", + "resolved": "https://registry.npmmirror.com/regjsgen/-/regjsgen-0.8.0.tgz", "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", "license": "MIT" }, "node_modules/regjsparser": { - "version": "0.13.1", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.1.tgz", - "integrity": "sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==", + "version": "0.13.0", + "resolved": "https://registry.npmmirror.com/regjsparser/-/regjsparser-0.13.0.tgz", + "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==", "license": "BSD-2-Clause", "dependencies": { "jsesc": "~3.1.0" @@ -14058,7 +13672,7 @@ }, "node_modules/remove-bom-buffer": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz", "integrity": "sha512-8v2rWhaakv18qcvNeli2mZ/TMTL2nEyAKRvzo1WtnZBl15SHyEhrCu2/xKlJyUFKHiHgfXIyuY6g2dObJJycXQ==", "dev": true, "license": "MIT", @@ -14072,7 +13686,7 @@ }, "node_modules/remove-bom-stream": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz", "integrity": "sha512-wigO8/O08XHb8YPzpDDT+QmRANfW6vLqxfaXm1YXhnFf3AkSLyjfG3GEFg4McZkmgL7KvCj5u2KczkvSP6NfHA==", "dev": true, "license": "MIT", @@ -14087,14 +13701,14 @@ }, "node_modules/remove-trailing-separator": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", "integrity": "sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw==", "dev": true, "license": "ISC" }, "node_modules/repeat-element": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/repeat-element/-/repeat-element-1.1.4.tgz", "integrity": "sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==", "dev": true, "license": "MIT", @@ -14104,7 +13718,7 @@ }, "node_modules/repeat-string": { "version": "1.6.1", - "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "resolved": "https://registry.npmmirror.com/repeat-string/-/repeat-string-1.6.1.tgz", "integrity": "sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==", "dev": true, "license": "MIT", @@ -14114,7 +13728,7 @@ }, "node_modules/replace-ext": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/replace-ext/-/replace-ext-1.0.1.tgz", "integrity": "sha512-yD5BHCe7quCgBph4rMQ+0KkIRKwWCrHDOX1p1Gp6HwjPM5kVoCdKGNhN7ydqqsX6lJEnQDKZ/tFMiEdQ1dvPEw==", "dev": true, "license": "MIT", @@ -14124,7 +13738,7 @@ }, "node_modules/replace-homedir": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/replace-homedir/-/replace-homedir-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/replace-homedir/-/replace-homedir-1.0.0.tgz", "integrity": "sha512-CHPV/GAglbIB1tnQgaiysb8H2yCy8WQ7lcEwQ/eT+kLj0QHV8LnJW0zpqpE7RSkrMSRoa+EBoag86clf7WAgSg==", "dev": true, "license": "MIT", @@ -14139,14 +13753,14 @@ }, "node_modules/reprism": { "version": "0.0.11", - "resolved": "https://registry.npmjs.org/reprism/-/reprism-0.0.11.tgz", + "resolved": "https://registry.npmmirror.com/reprism/-/reprism-0.0.11.tgz", "integrity": "sha512-VsxDR5QxZo08M/3nRypNlScw5r3rKeSOPdU/QhDmu3Ai3BJxHn/qgfXGWQp/tAxUtzwYNo9W6997JZR0tPLZsA==", "dev": true, "license": "MIT" }, "node_modules/require-directory": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", "dev": true, "license": "MIT", @@ -14156,7 +13770,7 @@ }, "node_modules/require-from-string": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/require-from-string/-/require-from-string-2.0.2.tgz", "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", "dev": true, "license": "MIT", @@ -14166,14 +13780,14 @@ }, "node_modules/require-main-filename": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/require-main-filename/-/require-main-filename-1.0.1.tgz", "integrity": "sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==", "dev": true, "license": "ISC" }, "node_modules/require-resolve": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/require-resolve/-/require-resolve-0.0.2.tgz", + "resolved": "https://registry.npmmirror.com/require-resolve/-/require-resolve-0.0.2.tgz", "integrity": "sha512-eafQVaxdQsWUB8HybwognkdcIdKdQdQBwTxH48FuE6WI0owZGKp63QYr1MRp73PoX0AcyB7MDapZThYUY8FD0A==", "license": "MIT", "dependencies": { @@ -14182,7 +13796,7 @@ }, "node_modules/requizzle": { "version": "0.2.4", - "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.4.tgz", + "resolved": "https://registry.npmmirror.com/requizzle/-/requizzle-0.2.4.tgz", "integrity": "sha512-JRrFk1D4OQ4SqovXOgdav+K8EAhSB/LJZqCz8tbX0KObcdeM15Ss59ozWMBWmmINMagCwmqn4ZNryUGpBsl6Jw==", "dev": true, "license": "MIT", @@ -14192,7 +13806,7 @@ }, "node_modules/resolve": { "version": "1.22.11", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", + "resolved": "https://registry.npmmirror.com/resolve/-/resolve-1.22.11.tgz", "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", "license": "MIT", "dependencies": { @@ -14212,7 +13826,7 @@ }, "node_modules/resolve-dir": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/resolve-dir/-/resolve-dir-1.0.1.tgz", "integrity": "sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==", "dev": true, "license": "MIT", @@ -14226,7 +13840,7 @@ }, "node_modules/resolve-from": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/resolve-from/-/resolve-from-4.0.0.tgz", "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", "dev": true, "license": "MIT", @@ -14236,7 +13850,7 @@ }, "node_modules/resolve-options": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/resolve-options/-/resolve-options-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/resolve-options/-/resolve-options-1.1.0.tgz", "integrity": "sha512-NYDgziiroVeDC29xq7bp/CacZERYsA9bXYd1ZmcJlF3BcrZv5pTb4NG7SjdyKDnXZ84aC4vo2u6sNKIA1LCu/A==", "dev": true, "license": "MIT", @@ -14249,7 +13863,7 @@ }, "node_modules/resolve-pkg-maps": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", "license": "MIT", "funding": { @@ -14258,7 +13872,7 @@ }, "node_modules/resolve-url": { "version": "0.2.1", - "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", + "resolved": "https://registry.npmmirror.com/resolve-url/-/resolve-url-0.2.1.tgz", "integrity": "sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==", "deprecated": "https://github.com/lydell/resolve-url#deprecated", "dev": true, @@ -14266,7 +13880,7 @@ }, "node_modules/ret": { "version": "0.1.15", - "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "resolved": "https://registry.npmmirror.com/ret/-/ret-0.1.15.tgz", "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", "dev": true, "license": "MIT", @@ -14276,7 +13890,7 @@ }, "node_modules/reusify": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/reusify/-/reusify-1.1.0.tgz", "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", "license": "MIT", "engines": { @@ -14286,13 +13900,13 @@ }, "node_modules/rfdc": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "resolved": "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz", "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", "license": "MIT" }, "node_modules/rimraf": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/rimraf/-/rimraf-3.0.2.tgz", "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", "deprecated": "Rimraf versions prior to v4 are no longer supported", "dev": true, @@ -14309,7 +13923,7 @@ }, "node_modules/run-parallel": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/run-parallel/-/run-parallel-1.2.0.tgz", "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", "funding": [ { @@ -14332,7 +13946,7 @@ }, "node_modules/safe-array-concat": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/safe-array-concat/-/safe-array-concat-1.1.3.tgz", "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==", "dev": true, "license": "MIT", @@ -14352,14 +13966,14 @@ }, "node_modules/safe-array-concat/node_modules/isarray": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/isarray/-/isarray-2.0.5.tgz", "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", "dev": true, "license": "MIT" }, "node_modules/safe-buffer": { "version": "5.2.1", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true, "funding": [ @@ -14380,7 +13994,7 @@ }, "node_modules/safe-push-apply": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/safe-push-apply/-/safe-push-apply-1.0.0.tgz", "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==", "dev": true, "license": "MIT", @@ -14397,14 +14011,14 @@ }, "node_modules/safe-push-apply/node_modules/isarray": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/isarray/-/isarray-2.0.5.tgz", "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", "dev": true, "license": "MIT" }, "node_modules/safe-regex": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/safe-regex/-/safe-regex-1.1.0.tgz", "integrity": "sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg==", "dev": true, "license": "MIT", @@ -14414,7 +14028,7 @@ }, "node_modules/safe-regex-test": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/safe-regex-test/-/safe-regex-test-1.1.0.tgz", "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", "dev": true, "license": "MIT", @@ -14432,7 +14046,7 @@ }, "node_modules/sax": { "version": "1.6.0", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz", + "resolved": "https://registry.npmmirror.com/sax/-/sax-1.6.0.tgz", "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==", "license": "BlueOak-1.0.0", "engines": { @@ -14441,7 +14055,7 @@ }, "node_modules/schema-utils": { "version": "4.3.3", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz", + "resolved": "https://registry.npmmirror.com/schema-utils/-/schema-utils-4.3.3.tgz", "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==", "dev": true, "license": "MIT", @@ -14461,7 +14075,7 @@ }, "node_modules/schema-utils/node_modules/ajv": { "version": "8.18.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz", + "resolved": "https://registry.npmmirror.com/ajv/-/ajv-8.18.0.tgz", "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "dev": true, "license": "MIT", @@ -14478,7 +14092,7 @@ }, "node_modules/schema-utils/node_modules/ajv-formats": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ajv-formats/-/ajv-formats-2.1.1.tgz", "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==", "dev": true, "license": "MIT", @@ -14496,7 +14110,7 @@ }, "node_modules/schema-utils/node_modules/ajv-keywords": { "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "resolved": "https://registry.npmmirror.com/ajv-keywords/-/ajv-keywords-5.1.0.tgz", "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", "dev": true, "license": "MIT", @@ -14509,14 +14123,14 @@ }, "node_modules/schema-utils/node_modules/json-schema-traverse": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", "dev": true, "license": "MIT" }, "node_modules/semver": { "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.4.tgz", "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "license": "ISC", "bin": { @@ -14528,7 +14142,7 @@ }, "node_modules/semver-greatest-satisfied-range": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz", "integrity": "sha512-Ny/iyOzSSa8M5ML46IAx3iXc6tfOsYU2R4AXi2UpHk60Zrgyq6eqPj/xiOfS0rRl/iiQ/rdJkVjw/5cdUyCntQ==", "dev": true, "license": "MIT", @@ -14541,7 +14155,7 @@ }, "node_modules/serialize-javascript": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/serialize-javascript/-/serialize-javascript-5.0.1.tgz", "integrity": "sha512-SaaNal9imEO737H2c05Og0/8LUXG7EnsZyMa8MzkmuHoELfT6txuj0cMqRj6zfPKnmQ1yasR4PCJc8x+M4JSPA==", "dev": true, "license": "BSD-3-Clause", @@ -14551,14 +14165,14 @@ }, "node_modules/set-blocking": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/set-blocking/-/set-blocking-2.0.0.tgz", "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", "dev": true, "license": "ISC" }, "node_modules/set-function-length": { "version": "1.2.2", - "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "resolved": "https://registry.npmmirror.com/set-function-length/-/set-function-length-1.2.2.tgz", "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", "dev": true, "license": "MIT", @@ -14576,7 +14190,7 @@ }, "node_modules/set-function-name": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/set-function-name/-/set-function-name-2.0.2.tgz", "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==", "dev": true, "license": "MIT", @@ -14592,7 +14206,7 @@ }, "node_modules/set-proto": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/set-proto/-/set-proto-1.0.0.tgz", "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==", "dev": true, "license": "MIT", @@ -14607,7 +14221,7 @@ }, "node_modules/set-value": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/set-value/-/set-value-2.0.1.tgz", "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", "dev": true, "license": "MIT", @@ -14623,7 +14237,7 @@ }, "node_modules/set-value/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -14636,7 +14250,7 @@ }, "node_modules/shebang-command": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/shebang-command/-/shebang-command-2.0.0.tgz", "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", "dev": true, "license": "MIT", @@ -14649,7 +14263,7 @@ }, "node_modules/shebang-regex": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/shebang-regex/-/shebang-regex-3.0.0.tgz", "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", "dev": true, "license": "MIT", @@ -14659,7 +14273,7 @@ }, "node_modules/side-channel": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/side-channel/-/side-channel-1.1.0.tgz", "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", "dev": true, "license": "MIT", @@ -14679,7 +14293,7 @@ }, "node_modules/side-channel-list": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/side-channel-list/-/side-channel-list-1.0.0.tgz", "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", "dev": true, "license": "MIT", @@ -14696,7 +14310,7 @@ }, "node_modules/side-channel-map": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/side-channel-map/-/side-channel-map-1.0.1.tgz", "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", "dev": true, "license": "MIT", @@ -14715,7 +14329,7 @@ }, "node_modules/side-channel-weakmap": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", "dev": true, "license": "MIT", @@ -14735,14 +14349,14 @@ }, "node_modules/signal-exit": { "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "resolved": "https://registry.npmmirror.com/signal-exit/-/signal-exit-3.0.7.tgz", "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", "dev": true, "license": "ISC" }, "node_modules/simple-concat": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/simple-concat/-/simple-concat-1.0.1.tgz", "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==", "dev": true, "funding": [ @@ -14763,7 +14377,7 @@ }, "node_modules/simple-get": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz", + "resolved": "https://registry.npmmirror.com/simple-get/-/simple-get-4.0.1.tgz", "integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==", "dev": true, "funding": [ @@ -14788,16 +14402,14 @@ } }, "node_modules/simple-git": { - "version": "3.35.2", - "resolved": "https://registry.npmjs.org/simple-git/-/simple-git-3.35.2.tgz", - "integrity": "sha512-ZMjl06lzTm1EScxEGuM6+mEX+NQd14h/B3x0vWU+YOXAMF8sicyi1K4cjTfj5is+35ChJEHDl1EjypzYFWH2FA==", + "version": "3.33.0", + "resolved": "https://registry.npmmirror.com/simple-git/-/simple-git-3.33.0.tgz", + "integrity": "sha512-D4V/tGC2sjsoNhoMybKyGoE+v8A60hRawKQ1iFRA1zwuDgGZCBJ4ByOzZ5J8joBbi4Oam0qiPH+GhzmSBwbJng==", "dev": true, "license": "MIT", "dependencies": { "@kwsites/file-exists": "^1.1.1", "@kwsites/promise-deferred": "^1.1.1", - "@simple-git/args-pathspec": "^1.0.2", - "@simple-git/argv-parser": "^1.0.3", "debug": "^4.4.0" }, "funding": { @@ -14807,7 +14419,7 @@ }, "node_modules/slash": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/slash/-/slash-3.0.0.tgz", "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", "dev": true, "license": "MIT", @@ -14817,7 +14429,7 @@ }, "node_modules/snapdragon": { "version": "0.8.2", - "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", + "resolved": "https://registry.npmmirror.com/snapdragon/-/snapdragon-0.8.2.tgz", "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", "dev": true, "license": "MIT", @@ -14837,7 +14449,7 @@ }, "node_modules/snapdragon-node": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz", "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", "dev": true, "license": "MIT", @@ -14852,7 +14464,7 @@ }, "node_modules/snapdragon-node/node_modules/define-property": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-1.0.0.tgz", "integrity": "sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==", "dev": true, "license": "MIT", @@ -14865,7 +14477,7 @@ }, "node_modules/snapdragon-node/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -14879,7 +14491,7 @@ }, "node_modules/snapdragon-util": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz", "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", "dev": true, "license": "MIT", @@ -14892,7 +14504,7 @@ }, "node_modules/snapdragon-util/node_modules/kind-of": { "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==", "dev": true, "license": "MIT", @@ -14905,7 +14517,7 @@ }, "node_modules/snapdragon/node_modules/debug": { "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", "dev": true, "license": "MIT", @@ -14915,14 +14527,14 @@ }, "node_modules/snapdragon/node_modules/ms": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz", "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "dev": true, "license": "MIT" }, "node_modules/snapdragon/node_modules/source-map": { "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.5.7.tgz", "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", "dev": true, "license": "BSD-3-Clause", @@ -14932,7 +14544,7 @@ }, "node_modules/source-map": { "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", "devOptional": true, "license": "BSD-3-Clause", @@ -14942,7 +14554,7 @@ }, "node_modules/source-map-resolve": { "version": "0.5.3", - "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz", + "resolved": "https://registry.npmmirror.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz", "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==", "deprecated": "See https://github.com/lydell/source-map-resolve#deprecated", "dev": true, @@ -14957,7 +14569,7 @@ }, "node_modules/source-map-support": { "version": "0.5.21", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "resolved": "https://registry.npmmirror.com/source-map-support/-/source-map-support-0.5.21.tgz", "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", "dev": true, "license": "MIT", @@ -14968,7 +14580,7 @@ }, "node_modules/source-map-url": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz", + "resolved": "https://registry.npmmirror.com/source-map-url/-/source-map-url-0.4.1.tgz", "integrity": "sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==", "deprecated": "See https://github.com/lydell/source-map-url#deprecated", "dev": true, @@ -14976,14 +14588,14 @@ }, "node_modules/spark-md5": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/spark-md5/-/spark-md5-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/spark-md5/-/spark-md5-3.0.2.tgz", "integrity": "sha512-wcFzz9cDfbuqe0FZzfi2or1sgyIrsDwmPwfZC4hiNidPdPINjeUwNfv5kldczoEAcjl9Y1L3SM7Uz2PUEQzxQw==", "dev": true, "license": "(WTFPL OR MIT)" }, "node_modules/sparkles": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/sparkles/-/sparkles-1.0.1.tgz", "integrity": "sha512-dSO0DDYUahUt/0/pD/Is3VIm5TGJjludZ0HVymmhYF6eNA53PVLhnUk0znSYbH8IYBuJdCE+1luR22jNLMaQdw==", "dev": true, "license": "MIT", @@ -14993,7 +14605,7 @@ }, "node_modules/spdx-correct": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", + "resolved": "https://registry.npmmirror.com/spdx-correct/-/spdx-correct-3.2.0.tgz", "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", "dev": true, "license": "Apache-2.0", @@ -15004,7 +14616,7 @@ }, "node_modules/spdx-correct/node_modules/spdx-expression-parse": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", "dev": true, "license": "MIT", @@ -15015,14 +14627,14 @@ }, "node_modules/spdx-exceptions": { "version": "2.5.0", - "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", + "resolved": "https://registry.npmmirror.com/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==", "dev": true, "license": "CC-BY-3.0" }, "node_modules/spdx-expression-parse": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/spdx-expression-parse/-/spdx-expression-parse-4.0.0.tgz", "integrity": "sha512-Clya5JIij/7C6bRR22+tnGXbc4VKlibKSVj2iHvVeX5iMW7s1SIQlqu699JkODJJIhh/pUu8L0/VLh8xflD+LQ==", "dev": true, "license": "MIT", @@ -15033,14 +14645,14 @@ }, "node_modules/spdx-license-ids": { "version": "3.0.23", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz", + "resolved": "https://registry.npmmirror.com/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz", "integrity": "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==", "dev": true, "license": "CC0-1.0" }, "node_modules/split-string": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/split-string/-/split-string-3.1.0.tgz", "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", "dev": true, "license": "MIT", @@ -15053,7 +14665,7 @@ }, "node_modules/split-string/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -15067,7 +14679,7 @@ }, "node_modules/split-string/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -15080,7 +14692,7 @@ }, "node_modules/split-string/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -15093,7 +14705,7 @@ }, "node_modules/stack-trace": { "version": "0.0.10", - "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", + "resolved": "https://registry.npmmirror.com/stack-trace/-/stack-trace-0.0.10.tgz", "integrity": "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==", "dev": true, "license": "MIT", @@ -15103,7 +14715,7 @@ }, "node_modules/static-extend": { "version": "0.1.2", - "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", + "resolved": "https://registry.npmmirror.com/static-extend/-/static-extend-0.1.2.tgz", "integrity": "sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g==", "dev": true, "license": "MIT", @@ -15117,7 +14729,7 @@ }, "node_modules/stop-iteration-iterator": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz", "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==", "dev": true, "license": "MIT", @@ -15131,14 +14743,14 @@ }, "node_modules/stream-exhaust": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/stream-exhaust/-/stream-exhaust-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/stream-exhaust/-/stream-exhaust-1.0.2.tgz", "integrity": "sha512-b/qaq/GlBK5xaq1yrK9/zFcyRSTNxmcZwFLGSTG0mXgZl/4Z6GgiyYOXOvY7N3eEvFRAG1bkDRz5EPGSvPYQlw==", "dev": true, "license": "MIT" }, "node_modules/stream-meter": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/stream-meter/-/stream-meter-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/stream-meter/-/stream-meter-1.0.4.tgz", "integrity": "sha512-4sOEtrbgFotXwnEuzzsQBYEV1elAeFSO8rSGeTwabuX1RRn/kEq9JVH7I0MRBhKVRR0sJkr0M0QCH7yOLf9fhQ==", "dev": true, "license": "MIT", @@ -15148,14 +14760,14 @@ }, "node_modules/stream-shift": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/stream-shift/-/stream-shift-1.0.3.tgz", "integrity": "sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==", "dev": true, "license": "MIT" }, "node_modules/streamroller": { "version": "3.1.5", - "resolved": "https://registry.npmjs.org/streamroller/-/streamroller-3.1.5.tgz", + "resolved": "https://registry.npmmirror.com/streamroller/-/streamroller-3.1.5.tgz", "integrity": "sha512-KFxaM7XT+irxvdqSP1LGLgNWbYN7ay5owZ3r/8t77p+EtSUAfUgtl7be3xtqtOmGUl9K9YPO2ca8133RlTjvKw==", "license": "MIT", "dependencies": { @@ -15169,7 +14781,7 @@ }, "node_modules/streamroller/node_modules/fs-extra": { "version": "8.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "resolved": "https://registry.npmmirror.com/fs-extra/-/fs-extra-8.1.0.tgz", "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", "license": "MIT", "dependencies": { @@ -15183,7 +14795,7 @@ }, "node_modules/streamroller/node_modules/jsonfile": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/jsonfile/-/jsonfile-4.0.0.tgz", "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", "license": "MIT", "optionalDependencies": { @@ -15192,7 +14804,7 @@ }, "node_modules/string_decoder": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, "license": "MIT", @@ -15202,21 +14814,21 @@ }, "node_modules/string_decoder/node_modules/safe-buffer": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", "dev": true, "license": "MIT" }, "node_modules/string-template": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/string-template/-/string-template-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/string-template/-/string-template-1.0.0.tgz", "integrity": "sha512-SLqR3GBUXuoPP5MmYtD7ompvXiG87QjT6lzOszyXjTM86Uu7At7vNnt2xgyTLq5o9T4IxTYFyGxcULqpsmsfdg==", "dev": true, "license": "MIT" }, "node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "resolved": "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, "license": "MIT", @@ -15231,7 +14843,7 @@ }, "node_modules/string.prototype.trim": { "version": "1.2.10", - "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", + "resolved": "https://registry.npmmirror.com/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==", "dev": true, "license": "MIT", @@ -15253,7 +14865,7 @@ }, "node_modules/string.prototype.trimend": { "version": "1.0.9", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", + "resolved": "https://registry.npmmirror.com/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==", "dev": true, "license": "MIT", @@ -15272,7 +14884,7 @@ }, "node_modules/string.prototype.trimstart": { "version": "1.0.8", - "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", + "resolved": "https://registry.npmmirror.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==", "dev": true, "license": "MIT", @@ -15290,7 +14902,7 @@ }, "node_modules/stringz": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/stringz/-/stringz-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/stringz/-/stringz-2.1.0.tgz", "integrity": "sha512-KlywLT+MZ+v0IRepfMxRtnSvDCMc3nR1qqCs3m/qIbSOWkNZYT8XHQA31rS3TnKp0c5xjZu3M4GY/2aRKSi/6A==", "dev": true, "license": "MIT", @@ -15300,7 +14912,7 @@ }, "node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, "license": "MIT", @@ -15313,7 +14925,7 @@ }, "node_modules/strip-bom": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/strip-bom/-/strip-bom-3.0.0.tgz", "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", "dev": true, "license": "MIT", @@ -15323,7 +14935,7 @@ }, "node_modules/strip-final-newline": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz", "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", "dev": true, "license": "MIT", @@ -15333,7 +14945,7 @@ }, "node_modules/strip-json-comments": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz", "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, "license": "MIT", @@ -15346,7 +14958,7 @@ }, "node_modules/stubborn-fs": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/stubborn-fs/-/stubborn-fs-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/stubborn-fs/-/stubborn-fs-2.0.0.tgz", "integrity": "sha512-Y0AvSwDw8y+nlSNFXMm2g6L51rBGdAQT20J3YSOqxC53Lo3bjWRtr2BKcfYoAf352WYpsZSTURrA0tqhfgudPA==", "dev": true, "license": "MIT", @@ -15356,14 +14968,14 @@ }, "node_modules/stubborn-utils": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/stubborn-utils/-/stubborn-utils-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/stubborn-utils/-/stubborn-utils-1.0.2.tgz", "integrity": "sha512-zOh9jPYI+xrNOyisSelgym4tolKTJCQd5GBhK0+0xJvcYDcwlOoxF/rnFKQ2KRZknXSG9jWAp66fwP6AxN9STg==", "dev": true, "license": "MIT" }, "node_modules/supports-color": { "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-5.5.0.tgz", "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", "license": "MIT", "dependencies": { @@ -15375,7 +14987,7 @@ }, "node_modules/supports-preserve-symlinks-flag": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", "license": "MIT", "engines": { @@ -15387,7 +14999,7 @@ }, "node_modules/sver-compat": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/sver-compat/-/sver-compat-1.5.0.tgz", + "resolved": "https://registry.npmmirror.com/sver-compat/-/sver-compat-1.5.0.tgz", "integrity": "sha512-aFTHfmjwizMNlNE6dsGmoAM4lHjL0CyiobWaFiXWSlD7cIxshW422Nb8KbXCmR6z+0ZEPY+daXJrDyh/vuwTyg==", "dev": true, "license": "MIT", @@ -15398,7 +15010,7 @@ }, "node_modules/synckit": { "version": "0.11.12", - "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.11.12.tgz", + "resolved": "https://registry.npmmirror.com/synckit/-/synckit-0.11.12.tgz", "integrity": "sha512-Bh7QjT8/SuKUIfObSXNHNSK6WHo6J1tHCqJsuaFDP7gP0fkzSfTxI8y85JrppZ0h8l0maIgc2tfuZQ6/t3GtnQ==", "dev": true, "license": "MIT", @@ -15414,7 +15026,7 @@ }, "node_modules/tagged-tag": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/tagged-tag/-/tagged-tag-1.0.0.tgz", "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==", "dev": true, "license": "MIT", @@ -15427,7 +15039,7 @@ }, "node_modules/tapable": { "version": "2.3.2", - "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.2.tgz", + "resolved": "https://registry.npmmirror.com/tapable/-/tapable-2.3.2.tgz", "integrity": "sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA==", "dev": true, "license": "MIT", @@ -15441,7 +15053,7 @@ }, "node_modules/tar-fs": { "version": "2.1.4", - "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz", + "resolved": "https://registry.npmmirror.com/tar-fs/-/tar-fs-2.1.4.tgz", "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==", "dev": true, "license": "MIT", @@ -15454,7 +15066,7 @@ }, "node_modules/tar-stream": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz", + "resolved": "https://registry.npmmirror.com/tar-stream/-/tar-stream-2.2.0.tgz", "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==", "dev": true, "license": "MIT", @@ -15471,7 +15083,7 @@ }, "node_modules/tar-stream/node_modules/readable-stream": { "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "resolved": "https://registry.npmmirror.com/readable-stream/-/readable-stream-3.6.2.tgz", "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "dev": true, "license": "MIT", @@ -15486,7 +15098,7 @@ }, "node_modules/temp": { "version": "0.4.0", - "resolved": "https://registry.npmjs.org/temp/-/temp-0.4.0.tgz", + "resolved": "https://registry.npmmirror.com/temp/-/temp-0.4.0.tgz", "integrity": "sha512-IsFisGgDKk7qzK9erMIkQe/XwiSUdac7z3wYOsjcLkhPBy3k1SlvLoIh2dAHIlEpgA971CgguMrx9z8fFg7tSA==", "engines": [ "node >=0.4.0" @@ -15494,7 +15106,7 @@ }, "node_modules/terser": { "version": "5.46.1", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.1.tgz", + "resolved": "https://registry.npmmirror.com/terser/-/terser-5.46.1.tgz", "integrity": "sha512-vzCjQO/rgUuK9sf8VJZvjqiqiHFaZLnOiimmUuOKODxWL8mm/xua7viT7aqX7dgPY60otQjUotzFMmCB4VdmqQ==", "dev": true, "license": "BSD-2-Clause", @@ -15513,7 +15125,7 @@ }, "node_modules/terser-webpack-plugin": { "version": "5.4.0", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.4.0.tgz", + "resolved": "https://registry.npmmirror.com/terser-webpack-plugin/-/terser-webpack-plugin-5.4.0.tgz", "integrity": "sha512-Bn5vxm48flOIfkdl5CaD2+1CiUVbonWQ3KQPyP7/EuIl9Gbzq/gQFOzaMFUEgVjB1396tcK0SG8XcNJ/2kDH8g==", "dev": true, "license": "MIT", @@ -15547,27 +15159,27 @@ }, "node_modules/terser/node_modules/commander": { "version": "2.20.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "resolved": "https://registry.npmmirror.com/commander/-/commander-2.20.3.tgz", "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", "dev": true, "license": "MIT" }, "node_modules/text-table": { "version": "0.2.0", - "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "resolved": "https://registry.npmmirror.com/text-table/-/text-table-0.2.0.tgz", "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", "dev": true, "license": "MIT" }, "node_modules/through": { "version": "2.3.8", - "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "resolved": "https://registry.npmmirror.com/through/-/through-2.3.8.tgz", "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==", "license": "MIT" }, "node_modules/through2": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/through2/-/through2-2.0.5.tgz", "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", "dev": true, "license": "MIT", @@ -15578,7 +15190,7 @@ }, "node_modules/through2-filter": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/through2-filter/-/through2-filter-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/through2-filter/-/through2-filter-3.0.0.tgz", "integrity": "sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==", "dev": true, "license": "MIT", @@ -15589,7 +15201,7 @@ }, "node_modules/time-stamp": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/time-stamp/-/time-stamp-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/time-stamp/-/time-stamp-1.1.0.tgz", "integrity": "sha512-gLCeArryy2yNTRzTGKbZbloctj64jkZ57hj5zdraXue6aFgd6PmvVtEyiUU+hvU0v7q08oVv8r8ev0tRo6bvgw==", "dev": true, "license": "MIT", @@ -15599,7 +15211,7 @@ }, "node_modules/tmp": { "version": "0.2.5", - "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz", + "resolved": "https://registry.npmmirror.com/tmp/-/tmp-0.2.5.tgz", "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==", "license": "MIT", "engines": { @@ -15608,7 +15220,7 @@ }, "node_modules/to-absolute-glob": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz", "integrity": "sha512-rtwLUQEwT8ZeKQbyFJyomBRYXyE16U5VKuy0ftxLMK/PZb2fkOsg5r9kHdauuVDbsNdIBoC/HCthpidamQFXYA==", "dev": true, "license": "MIT", @@ -15622,7 +15234,7 @@ }, "node_modules/to-fast-properties": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz", "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", "license": "MIT", "engines": { @@ -15631,7 +15243,7 @@ }, "node_modules/to-object-path": { "version": "0.3.0", - "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", + "resolved": "https://registry.npmmirror.com/to-object-path/-/to-object-path-0.3.0.tgz", "integrity": "sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg==", "dev": true, "license": "MIT", @@ -15644,7 +15256,7 @@ }, "node_modules/to-object-path/node_modules/kind-of": { "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "resolved": "https://registry.npmmirror.com/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==", "dev": true, "license": "MIT", @@ -15657,7 +15269,7 @@ }, "node_modules/to-regex": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/to-regex/-/to-regex-3.0.2.tgz", "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", "dev": true, "license": "MIT", @@ -15673,7 +15285,7 @@ }, "node_modules/to-regex-range": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-2.1.1.tgz", "integrity": "sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg==", "dev": true, "license": "MIT", @@ -15687,7 +15299,7 @@ }, "node_modules/to-regex/node_modules/define-property": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "license": "MIT", @@ -15701,7 +15313,7 @@ }, "node_modules/to-regex/node_modules/extend-shallow": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "resolved": "https://registry.npmmirror.com/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==", "dev": true, "license": "MIT", @@ -15715,7 +15327,7 @@ }, "node_modules/to-regex/node_modules/is-descriptor": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/is-descriptor/-/is-descriptor-1.0.3.tgz", "integrity": "sha512-JCNNGbwWZEVaSPtS45mdtrneRWJFp07LLmykxeFV5F6oBvNF8vHSfJuJgoT472pSfk+Mf8VnlrspaFBHWM8JAw==", "dev": true, "license": "MIT", @@ -15729,7 +15341,7 @@ }, "node_modules/to-regex/node_modules/is-extendable": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "license": "MIT", @@ -15742,7 +15354,7 @@ }, "node_modules/to-regex/node_modules/is-plain-object": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "license": "MIT", @@ -15755,7 +15367,7 @@ }, "node_modules/to-through": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-through/-/to-through-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/to-through/-/to-through-2.0.0.tgz", "integrity": "sha512-+QIz37Ly7acM4EMdw2PRN389OneM5+d844tirkGp4dPKzI5OE72V9OsbFp+CIYJDahZ41ZV05hNtcPAQUAm9/Q==", "dev": true, "license": "MIT", @@ -15768,20 +15380,39 @@ }, "node_modules/token-stream": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/token-stream/-/token-stream-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/token-stream/-/token-stream-1.0.0.tgz", "integrity": "sha512-VSsyNPPW74RpHwR8Fc21uubwHY7wMDeJLys2IX5zJNih+OnAnaifKHo+1LHT7DAdloQ7apeaaWg8l7qnf/TnEg==", "dev": true, "license": "MIT" }, "node_modules/tr46": { "version": "0.0.3", - "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "resolved": "https://registry.npmmirror.com/tr46/-/tr46-0.0.3.tgz", "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", "license": "MIT" }, + "node_modules/tree-sitter-php": { + "version": "0.24.2", + "resolved": "https://registry.npmmirror.com/tree-sitter-php/-/tree-sitter-php-0.24.2.tgz", + "integrity": "sha512-zwgAePc/HozNaWOOfwRAA+3p8yhuehRw8Fb7vn5qd2XjiIc93uJPryDTMYTSjBRjVIUg/KY6pM3rRzs8dSwKfw==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-addon-api": "^8.2.2", + "node-gyp-build": "^4.8.2" + }, + "peerDependencies": { + "tree-sitter": "^0.22.4" + }, + "peerDependenciesMeta": { + "tree-sitter": { + "optional": true + } + } + }, "node_modules/tsconfig-paths": { "version": "3.15.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz", + "resolved": "https://registry.npmmirror.com/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz", "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==", "dev": true, "license": "MIT", @@ -15794,7 +15425,7 @@ }, "node_modules/tsconfig-paths/node_modules/json5": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/json5/-/json5-1.0.2.tgz", "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", "dev": true, "license": "MIT", @@ -15807,14 +15438,14 @@ }, "node_modules/tslib": { "version": "2.8.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz", "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", "dev": true, "license": "0BSD" }, "node_modules/tsutils": { "version": "3.21.0", - "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "resolved": "https://registry.npmmirror.com/tsutils/-/tsutils-3.21.0.tgz", "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", "dev": true, "license": "MIT", @@ -15830,14 +15461,14 @@ }, "node_modules/tsutils/node_modules/tslib": { "version": "1.14.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "resolved": "https://registry.npmmirror.com/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", "dev": true, "license": "0BSD" }, "node_modules/tsx": { "version": "4.21.0", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "resolved": "https://registry.npmmirror.com/tsx/-/tsx-4.21.0.tgz", "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", "license": "MIT", "dependencies": { @@ -15856,7 +15487,7 @@ }, "node_modules/tsx/node_modules/fsevents": { "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", "hasInstallScript": true, "license": "MIT", @@ -15870,7 +15501,7 @@ }, "node_modules/tunnel-agent": { "version": "0.6.0", - "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "resolved": "https://registry.npmmirror.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz", "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", "dev": true, "license": "Apache-2.0", @@ -15883,14 +15514,14 @@ }, "node_modules/type": { "version": "2.7.3", - "resolved": "https://registry.npmjs.org/type/-/type-2.7.3.tgz", + "resolved": "https://registry.npmmirror.com/type/-/type-2.7.3.tgz", "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==", "dev": true, "license": "ISC" }, "node_modules/type-check": { "version": "0.4.0", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "resolved": "https://registry.npmmirror.com/type-check/-/type-check-0.4.0.tgz", "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", "dev": true, "license": "MIT", @@ -15903,7 +15534,7 @@ }, "node_modules/type-detect": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.1.0.tgz", + "resolved": "https://registry.npmmirror.com/type-detect/-/type-detect-4.1.0.tgz", "integrity": "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==", "dev": true, "license": "MIT", @@ -15913,7 +15544,7 @@ }, "node_modules/type-fest": { "version": "5.5.0", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.5.0.tgz", + "resolved": "https://registry.npmmirror.com/type-fest/-/type-fest-5.5.0.tgz", "integrity": "sha512-PlBfpQwiUvGViBNX84Yxwjsdhd1TUlXr6zjX7eoirtCPIr08NAmxwa+fcYBTeRQxHo9YC9wwF3m9i700sHma8g==", "dev": true, "license": "(MIT OR CC0-1.0)", @@ -15929,7 +15560,7 @@ }, "node_modules/typed-array-buffer": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", "dev": true, "license": "MIT", @@ -15944,7 +15575,7 @@ }, "node_modules/typed-array-byte-length": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", + "resolved": "https://registry.npmmirror.com/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==", "dev": true, "license": "MIT", @@ -15964,7 +15595,7 @@ }, "node_modules/typed-array-byte-offset": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", + "resolved": "https://registry.npmmirror.com/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==", "dev": true, "license": "MIT", @@ -15986,7 +15617,7 @@ }, "node_modules/typed-array-length": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz", + "resolved": "https://registry.npmmirror.com/typed-array-length/-/typed-array-length-1.0.7.tgz", "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==", "dev": true, "license": "MIT", @@ -16007,16 +15638,15 @@ }, "node_modules/typedarray": { "version": "0.0.6", - "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "resolved": "https://registry.npmmirror.com/typedarray/-/typedarray-0.0.6.tgz", "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==", "dev": true, "license": "MIT" }, "node_modules/typescript": { "version": "5.9.3", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz", "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", - "dev": true, "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", @@ -16028,20 +15658,20 @@ }, "node_modules/uc.micro": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/uc.micro/-/uc.micro-2.1.0.tgz", "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==", "dev": true, "license": "MIT" }, "node_modules/uglify-es": { "version": "3.3.10", - "resolved": "https://registry.npmjs.org/uglify-es/-/uglify-es-3.3.10.tgz", - "integrity": "sha512-rPzPisCzW68Okj1zNrfa2dR9uEm43SevDmpR6FChoZABFk9dANGnzzBMgHYUXI3609//63fnVkyQ1SQmAMyjww==", - "deprecated": "support for ECMAScript is superseded by `uglify-js` as of v3.13.0", + "resolved": "https://registry.npmmirror.com/uglify-es/-/uglify-es-3.3.9.tgz", + "integrity": "sha512-r+MU0rfv4L/0eeW3xZrd16t4NZfK8Ld4SWVglYBb7ez5uXFWHuVRs6xCTrf1yirs9a4j4Y27nn7SRfO6v67XsQ==", + "deprecated": "support for ECMAScript is superseded by `uglify-js` as of v3.13.0 ([WARNING] Use 3.3.9 instead of 3.3.10, reason: see https://github.com/mishoo/UglifyJS2/issues/2896)", "dev": true, "license": "BSD-2-Clause", "dependencies": { - "commander": "~2.14.1", + "commander": "~2.13.0", "source-map": "~0.6.1" }, "bin": { @@ -16052,15 +15682,15 @@ } }, "node_modules/uglify-es/node_modules/commander": { - "version": "2.14.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.14.1.tgz", - "integrity": "sha512-+YR16o3rK53SmWHU3rEM3tPAh2rwb1yPcQX5irVn7mb0gXbwuCCrnkbV5+PBfETdfg1vui07nM6PCG1zndcjQw==", + "version": "2.13.0", + "resolved": "https://registry.npmmirror.com/commander/-/commander-2.13.0.tgz", + "integrity": "sha512-MVuS359B+YzaWqjCL/c+22gfryv+mCBPHAv3zyVI2GN8EY6IRP8VwtasXn8jyyhvvq84R4ImN1OKRtcbIasjYA==", "dev": true, "license": "MIT" }, "node_modules/uglify-js": { "version": "3.19.3", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz", + "resolved": "https://registry.npmmirror.com/uglify-js/-/uglify-js-3.19.3.tgz", "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==", "dev": true, "license": "BSD-2-Clause", @@ -16073,7 +15703,7 @@ }, "node_modules/uint8array-extras": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz", + "resolved": "https://registry.npmmirror.com/uint8array-extras/-/uint8array-extras-1.5.0.tgz", "integrity": "sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==", "dev": true, "license": "MIT", @@ -16086,7 +15716,7 @@ }, "node_modules/unbox-primitive": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/unbox-primitive/-/unbox-primitive-1.1.0.tgz", "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", "dev": true, "license": "MIT", @@ -16105,7 +15735,7 @@ }, "node_modules/unc-path-regex": { "version": "0.1.2", - "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz", + "resolved": "https://registry.npmmirror.com/unc-path-regex/-/unc-path-regex-0.1.2.tgz", "integrity": "sha512-eXL4nmJT7oCpkZsHZUOJo8hcX3GbsiDOa0Qu9F646fi8dT3XuSVopVqAcEiVzSKKH7UoDti23wNX3qGFxcW5Qg==", "dev": true, "license": "MIT", @@ -16115,13 +15745,13 @@ }, "node_modules/underscore": { "version": "1.13.8", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.8.tgz", + "resolved": "https://registry.npmmirror.com/underscore/-/underscore-1.13.8.tgz", "integrity": "sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==", "license": "MIT" }, "node_modules/undertaker": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/undertaker/-/undertaker-1.3.0.tgz", + "resolved": "https://registry.npmmirror.com/undertaker/-/undertaker-1.3.0.tgz", "integrity": "sha512-/RXwi5m/Mu3H6IHQGww3GNt1PNXlbeCuclF2QYR14L/2CHPz3DFZkvB5hZ0N/QUkiXWCACML2jXViIQEQc2MLg==", "dev": true, "license": "MIT", @@ -16143,7 +15773,7 @@ }, "node_modules/undertaker-registry": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/undertaker-registry/-/undertaker-registry-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/undertaker-registry/-/undertaker-registry-1.0.1.tgz", "integrity": "sha512-UR1khWeAjugW3548EfQmL9Z7pGMlBgXteQpr1IZeZBtnkCJQJIJ1Scj0mb9wQaPvUZ9Q17XqW6TIaPchJkyfqw==", "dev": true, "license": "MIT", @@ -16153,21 +15783,21 @@ }, "node_modules/undertaker/node_modules/fast-levenshtein": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz", + "resolved": "https://registry.npmmirror.com/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz", "integrity": "sha512-Ia0sQNrMPXXkqVFt6w6M1n1oKo3NfKs+mvaV811Jwir7vAk9a6PVV9VPYf6X3BU97QiLEmuW3uXH9u87zDFfdw==", "dev": true, "license": "MIT" }, "node_modules/undici-types": { "version": "6.21.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz", "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", "dev": true, "license": "MIT" }, "node_modules/unicode-canonical-property-names-ecmascript": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", + "resolved": "https://registry.npmmirror.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==", "license": "MIT", "engines": { @@ -16176,7 +15806,7 @@ }, "node_modules/unicode-match-property-ecmascript": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", "license": "MIT", "dependencies": { @@ -16189,7 +15819,7 @@ }, "node_modules/unicode-match-property-value-ecmascript": { "version": "2.2.1", - "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz", + "resolved": "https://registry.npmmirror.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz", "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==", "license": "MIT", "engines": { @@ -16198,7 +15828,7 @@ }, "node_modules/unicode-property-aliases-ecmascript": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz", + "resolved": "https://registry.npmmirror.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz", "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==", "license": "MIT", "engines": { @@ -16207,7 +15837,7 @@ }, "node_modules/union-value": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", + "resolved": "https://registry.npmmirror.com/union-value/-/union-value-1.0.1.tgz", "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", "dev": true, "license": "MIT", @@ -16223,7 +15853,7 @@ }, "node_modules/unique-stream": { "version": "2.4.0", - "resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-2.4.0.tgz", + "resolved": "https://registry.npmmirror.com/unique-stream/-/unique-stream-2.4.0.tgz", "integrity": "sha512-V6QarSfeSgDipGA9EZdoIzu03ZDlOFkk+FbEP5cwgrZXN3iIkYR91IjU2EnM6rB835kGQsqHX8qncObTXV+6KA==", "dev": true, "license": "MIT", @@ -16234,7 +15864,7 @@ }, "node_modules/universalify": { "version": "0.1.2", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "resolved": "https://registry.npmmirror.com/universalify/-/universalify-0.1.2.tgz", "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", "license": "MIT", "engines": { @@ -16243,7 +15873,7 @@ }, "node_modules/unset-value": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/unset-value/-/unset-value-1.0.0.tgz", "integrity": "sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ==", "dev": true, "license": "MIT", @@ -16257,7 +15887,7 @@ }, "node_modules/unset-value/node_modules/has-value": { "version": "0.3.1", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", + "resolved": "https://registry.npmmirror.com/has-value/-/has-value-0.3.1.tgz", "integrity": "sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q==", "dev": true, "license": "MIT", @@ -16272,7 +15902,7 @@ }, "node_modules/unset-value/node_modules/has-value/node_modules/isobject": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/isobject/-/isobject-2.1.0.tgz", "integrity": "sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA==", "dev": true, "license": "MIT", @@ -16285,7 +15915,7 @@ }, "node_modules/unset-value/node_modules/has-values": { "version": "0.1.4", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", + "resolved": "https://registry.npmmirror.com/has-values/-/has-values-0.1.4.tgz", "integrity": "sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ==", "dev": true, "license": "MIT", @@ -16295,7 +15925,7 @@ }, "node_modules/upath": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "resolved": "https://registry.npmmirror.com/upath/-/upath-1.2.0.tgz", "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", "dev": true, "license": "MIT", @@ -16306,7 +15936,7 @@ }, "node_modules/update-browserslist-db": { "version": "1.2.3", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "resolved": "https://registry.npmmirror.com/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", "funding": [ { @@ -16336,7 +15966,7 @@ }, "node_modules/uri-js": { "version": "4.4.1", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "resolved": "https://registry.npmmirror.com/uri-js/-/uri-js-4.4.1.tgz", "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", "dev": true, "license": "BSD-2-Clause", @@ -16346,7 +15976,7 @@ }, "node_modules/urix": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", + "resolved": "https://registry.npmmirror.com/urix/-/urix-0.1.0.tgz", "integrity": "sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg==", "deprecated": "Please see https://github.com/lydell/urix#deprecated", "dev": true, @@ -16354,7 +15984,7 @@ }, "node_modules/use": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", + "resolved": "https://registry.npmmirror.com/use/-/use-3.1.1.tgz", "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", "dev": true, "license": "MIT", @@ -16364,7 +15994,7 @@ }, "node_modules/util": { "version": "0.12.5", - "resolved": "https://registry.npmjs.org/util/-/util-0.12.5.tgz", + "resolved": "https://registry.npmmirror.com/util/-/util-0.12.5.tgz", "integrity": "sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==", "dev": true, "license": "MIT", @@ -16378,14 +16008,14 @@ }, "node_modules/util-deprecate": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/util-deprecate/-/util-deprecate-1.0.2.tgz", "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", "dev": true, "license": "MIT" }, "node_modules/v8flags": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-3.2.0.tgz", + "resolved": "https://registry.npmmirror.com/v8flags/-/v8flags-3.2.0.tgz", "integrity": "sha512-mH8etigqMfiGWdeXpaaqGfs6BndypxusHHcv2qSHyZkGEznCd/qAXCWWRzeowtL54147cktFOC4P5y+kl8d8Jg==", "dev": true, "license": "MIT", @@ -16398,7 +16028,7 @@ }, "node_modules/validate-npm-package-license": { "version": "3.0.4", - "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "resolved": "https://registry.npmmirror.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", "dev": true, "license": "Apache-2.0", @@ -16409,7 +16039,7 @@ }, "node_modules/validate-npm-package-license/node_modules/spdx-expression-parse": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", "dev": true, "license": "MIT", @@ -16419,9 +16049,9 @@ } }, "node_modules/validator": { - "version": "13.15.35", - "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.35.tgz", - "integrity": "sha512-TQ5pAGhd5whStmqWvYF4OjQROlmv9SMFVt37qoCBdqRffuuklWYQlCNnEs2ZaIBD1kZRNnikiZOS1eqgkar0iw==", + "version": "13.15.26", + "resolved": "https://registry.npmmirror.com/validator/-/validator-13.15.26.tgz", + "integrity": "sha512-spH26xU080ydGggxRyR1Yhcbgx+j3y5jbNXk/8L+iRvdIEQ4uTRH2Sgf2dokud6Q4oAtsbNvJ1Ft+9xmm6IZcA==", "dev": true, "license": "MIT", "engines": { @@ -16430,7 +16060,7 @@ }, "node_modules/value-or-function": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/value-or-function/-/value-or-function-3.0.0.tgz", + "resolved": "https://registry.npmmirror.com/value-or-function/-/value-or-function-3.0.0.tgz", "integrity": "sha512-jdBB2FrWvQC/pnPtIqcLsMaQgjhdb6B7tk1MMyTKapox+tQZbdRP4uLxu/JY0t7fbfDCUMnuelzEYv5GsxHhdg==", "dev": true, "license": "MIT", @@ -16440,7 +16070,7 @@ }, "node_modules/vinyl": { "version": "2.2.1", - "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.1.tgz", + "resolved": "https://registry.npmmirror.com/vinyl/-/vinyl-2.2.1.tgz", "integrity": "sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==", "dev": true, "license": "MIT", @@ -16458,7 +16088,7 @@ }, "node_modules/vinyl-fs": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/vinyl-fs/-/vinyl-fs-3.0.3.tgz", + "resolved": "https://registry.npmmirror.com/vinyl-fs/-/vinyl-fs-3.0.3.tgz", "integrity": "sha512-vIu34EkyNyJxmP0jscNzWBSygh7VWhqun6RmqVfXePrOwi9lhvRs//dOaGOTRUQr4tx7/zd26Tk5WeSVZitgng==", "dev": true, "license": "MIT", @@ -16487,7 +16117,7 @@ }, "node_modules/vinyl-sourcemap": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz", + "resolved": "https://registry.npmmirror.com/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz", "integrity": "sha512-NiibMgt6VJGJmyw7vtzhctDcfKch4e4n9TBeoWlirb7FMg9/1Ov9k+A5ZRAtywBpRPiyECvQRQllYM8dECegVA==", "dev": true, "license": "MIT", @@ -16506,14 +16136,14 @@ }, "node_modules/vinyl-sourcemap/node_modules/convert-source-map": { "version": "1.9.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "resolved": "https://registry.npmmirror.com/convert-source-map/-/convert-source-map-1.9.0.tgz", "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", "dev": true, "license": "MIT" }, "node_modules/vinyl-sourcemap/node_modules/normalize-path": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/normalize-path/-/normalize-path-2.1.1.tgz", "integrity": "sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w==", "dev": true, "license": "MIT", @@ -16526,7 +16156,7 @@ }, "node_modules/vinyl-sourcemaps-apply": { "version": "0.2.1", - "resolved": "https://registry.npmjs.org/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz", + "resolved": "https://registry.npmmirror.com/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz", "integrity": "sha512-+oDh3KYZBoZC8hfocrbrxbLUeaYtQK7J5WU5Br9VqWqmCll3tFJqKp97GC9GmMsVIL0qnx2DgEDVxdo5EZ5sSw==", "dev": true, "license": "ISC", @@ -16536,7 +16166,7 @@ }, "node_modules/vinyl-sourcemaps-apply/node_modules/source-map": { "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.5.7.tgz", "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", "dev": true, "license": "BSD-3-Clause", @@ -16546,7 +16176,7 @@ }, "node_modules/void-elements": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-3.1.0.tgz", + "resolved": "https://registry.npmmirror.com/void-elements/-/void-elements-3.1.0.tgz", "integrity": "sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==", "dev": true, "license": "MIT", @@ -16556,7 +16186,7 @@ }, "node_modules/watchpack": { "version": "2.5.1", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.1.tgz", + "resolved": "https://registry.npmmirror.com/watchpack/-/watchpack-2.5.1.tgz", "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==", "dev": true, "license": "MIT", @@ -16568,15 +16198,21 @@ "node": ">=10.13.0" } }, + "node_modules/web-tree-sitter": { + "version": "0.26.8", + "resolved": "https://registry.npmmirror.com/web-tree-sitter/-/web-tree-sitter-0.26.8.tgz", + "integrity": "sha512-4sUwi7ZyOrIk5KLgYLkc2A/F0LFMQnBhfb+2Cdl7ik4ePJ6JD+fk4ofI2sA5eGawBKBaK4Vntt7Ww5KcEsay4A==", + "license": "MIT" + }, "node_modules/webidl-conversions": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz", "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", "license": "BSD-2-Clause" }, "node_modules/webpack": { "version": "5.105.4", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.4.tgz", + "resolved": "https://registry.npmmirror.com/webpack/-/webpack-5.105.4.tgz", "integrity": "sha512-jTywjboN9aHxFlToqb0K0Zs9SbBoW4zRUlGzI2tYNxVYcEi/IPpn+Xi4ye5jTLvX2YeLuic/IvxNot+Q1jMoOw==", "dev": true, "license": "MIT", @@ -16624,9 +16260,9 @@ } }, "node_modules/webpack-obfuscator": { - "version": "3.6.1", - "resolved": "https://registry.npmjs.org/webpack-obfuscator/-/webpack-obfuscator-3.6.1.tgz", - "integrity": "sha512-73swcDcQ+Ukejny8cMfUPZjw/rRCKeQbBVDTUNK0umEQSX8yVuWDIceKQO5579ftmOXwokrobUsNC0rQrkOuWQ==", + "version": "3.6.0", + "resolved": "https://registry.npmmirror.com/webpack-obfuscator/-/webpack-obfuscator-3.6.0.tgz", + "integrity": "sha512-Y/jRICYe08S6okfsL6UnC7PTwdumhYpXvwLdw4soGmVbQ0jldFjVDqRbPZnOc4PdOQSMDrnQNQB+b7Fc4rpx+A==", "dev": true, "license": "BSD-2-Clause", "dependencies": { @@ -16644,7 +16280,7 @@ }, "node_modules/webpack-sources": { "version": "3.3.4", - "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.4.tgz", + "resolved": "https://registry.npmmirror.com/webpack-sources/-/webpack-sources-3.3.4.tgz", "integrity": "sha512-7tP1PdV4vF+lYPnkMR0jMY5/la2ub5Fc/8VQrrU+lXkiM6C4TjVfGw7iKfyhnTQOsD+6Q/iKw0eFciziRgD58Q==", "dev": true, "license": "MIT", @@ -16654,7 +16290,7 @@ }, "node_modules/whatwg-url": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "resolved": "https://registry.npmmirror.com/whatwg-url/-/whatwg-url-5.0.0.tgz", "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", "license": "MIT", "dependencies": { @@ -16664,14 +16300,14 @@ }, "node_modules/when-exit": { "version": "2.1.5", - "resolved": "https://registry.npmjs.org/when-exit/-/when-exit-2.1.5.tgz", + "resolved": "https://registry.npmmirror.com/when-exit/-/when-exit-2.1.5.tgz", "integrity": "sha512-VGkKJ564kzt6Ms1dbgPP/yuIoQCrsFAnRbptpC5wOEsDaNsbCB2bnfnaA8i/vRs5tjUSEOtIuvl9/MyVsvQZCg==", "dev": true, "license": "MIT" }, "node_modules/which": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "resolved": "https://registry.npmmirror.com/which/-/which-2.0.2.tgz", "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", "dev": true, "license": "ISC", @@ -16687,7 +16323,7 @@ }, "node_modules/which-boxed-primitive": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "resolved": "https://registry.npmmirror.com/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", "dev": true, "license": "MIT", @@ -16707,7 +16343,7 @@ }, "node_modules/which-builtin-type": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "resolved": "https://registry.npmmirror.com/which-builtin-type/-/which-builtin-type-1.2.1.tgz", "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", "dev": true, "license": "MIT", @@ -16735,14 +16371,14 @@ }, "node_modules/which-builtin-type/node_modules/isarray": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "resolved": "https://registry.npmmirror.com/isarray/-/isarray-2.0.5.tgz", "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", "dev": true, "license": "MIT" }, "node_modules/which-collection": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/which-collection/-/which-collection-1.0.2.tgz", "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==", "dev": true, "license": "MIT", @@ -16761,14 +16397,14 @@ }, "node_modules/which-module": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/which-module/-/which-module-1.0.0.tgz", "integrity": "sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==", "dev": true, "license": "ISC" }, "node_modules/which-typed-array": { "version": "1.1.20", - "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.20.tgz", + "resolved": "https://registry.npmmirror.com/which-typed-array/-/which-typed-array-1.1.20.tgz", "integrity": "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==", "dev": true, "license": "MIT", @@ -16790,7 +16426,7 @@ }, "node_modules/wide-align": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", + "resolved": "https://registry.npmmirror.com/wide-align/-/wide-align-1.1.3.tgz", "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", "dev": true, "license": "ISC", @@ -16800,7 +16436,7 @@ }, "node_modules/wide-align/node_modules/ansi-regex": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-3.0.1.tgz", "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==", "dev": true, "license": "MIT", @@ -16810,7 +16446,7 @@ }, "node_modules/wide-align/node_modules/is-fullwidth-code-point": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", "dev": true, "license": "MIT", @@ -16820,7 +16456,7 @@ }, "node_modules/wide-align/node_modules/string-width": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/string-width/-/string-width-2.1.1.tgz", "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", "dev": true, "license": "MIT", @@ -16834,7 +16470,7 @@ }, "node_modules/wide-align/node_modules/strip-ansi": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-4.0.0.tgz", "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==", "dev": true, "license": "MIT", @@ -16847,7 +16483,7 @@ }, "node_modules/with": { "version": "7.0.2", - "resolved": "https://registry.npmjs.org/with/-/with-7.0.2.tgz", + "resolved": "https://registry.npmmirror.com/with/-/with-7.0.2.tgz", "integrity": "sha512-RNGKj82nUPg3g5ygxkQl0R937xLyho1J24ItRCBTr/m1YnZkzJy1hUiHUJrc/VlsDQzsCnInEGSg3bci0Lmd4w==", "dev": true, "license": "MIT", @@ -16863,7 +16499,7 @@ }, "node_modules/word-wrap": { "version": "1.2.5", - "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "resolved": "https://registry.npmmirror.com/word-wrap/-/word-wrap-1.2.5.tgz", "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", "dev": true, "license": "MIT", @@ -16873,14 +16509,14 @@ }, "node_modules/workerpool": { "version": "6.1.0", - "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.1.0.tgz", + "resolved": "https://registry.npmmirror.com/workerpool/-/workerpool-6.1.0.tgz", "integrity": "sha512-toV7q9rWNYha963Pl/qyeZ6wG+3nnsyvolaNUS8+R5Wtw6qJPTxIlOP1ZSvcGhEJw+l3HMMmtiNo9Gl61G4GVg==", "dev": true, "license": "Apache-2.0" }, "node_modules/wrap-ansi": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", + "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz", "integrity": "sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==", "dev": true, "license": "MIT", @@ -16894,7 +16530,7 @@ }, "node_modules/wrap-ansi/node_modules/ansi-regex": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-2.1.1.tgz", "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==", "dev": true, "license": "MIT", @@ -16904,7 +16540,7 @@ }, "node_modules/wrap-ansi/node_modules/is-fullwidth-code-point": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", "integrity": "sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==", "dev": true, "license": "MIT", @@ -16917,7 +16553,7 @@ }, "node_modules/wrap-ansi/node_modules/string-width": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/string-width/-/string-width-1.0.2.tgz", "integrity": "sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==", "dev": true, "license": "MIT", @@ -16932,7 +16568,7 @@ }, "node_modules/wrap-ansi/node_modules/strip-ansi": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==", "dev": true, "license": "MIT", @@ -16945,14 +16581,14 @@ }, "node_modules/wrappy": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/wrappy/-/wrappy-1.0.2.tgz", "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", "dev": true, "license": "ISC" }, "node_modules/x-path": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/x-path/-/x-path-0.0.2.tgz", + "resolved": "https://registry.npmmirror.com/x-path/-/x-path-0.0.2.tgz", "integrity": "sha512-zQ4WFI0XfJN1uEkkrB19Y4TuXOlHqKSxUJo0Yt+axPjRm8tCG6SJ6+Wo3/+Kjg4c2c8IvBXuJ0uYoshxNn4qMw==", "license": "MIT", "dependencies": { @@ -16961,7 +16597,7 @@ }, "node_modules/xml2js": { "version": "0.6.2", - "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.6.2.tgz", + "resolved": "https://registry.npmmirror.com/xml2js/-/xml2js-0.6.2.tgz", "integrity": "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==", "license": "MIT", "dependencies": { @@ -16974,7 +16610,7 @@ }, "node_modules/xmlbuilder": { "version": "11.0.1", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz", + "resolved": "https://registry.npmmirror.com/xmlbuilder/-/xmlbuilder-11.0.1.tgz", "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==", "license": "MIT", "engines": { @@ -16983,14 +16619,14 @@ }, "node_modules/xmlcreate": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.4.tgz", + "resolved": "https://registry.npmmirror.com/xmlcreate/-/xmlcreate-2.0.4.tgz", "integrity": "sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==", "dev": true, "license": "Apache-2.0" }, "node_modules/xtend": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "resolved": "https://registry.npmmirror.com/xtend/-/xtend-4.0.2.tgz", "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", "dev": true, "license": "MIT", @@ -17000,20 +16636,20 @@ }, "node_modules/y18n": { "version": "3.2.2", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.2.tgz", + "resolved": "https://registry.npmmirror.com/y18n/-/y18n-3.2.2.tgz", "integrity": "sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==", "dev": true, "license": "ISC" }, "node_modules/yallist": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "resolved": "https://registry.npmmirror.com/yallist/-/yallist-3.1.1.tgz", "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", "license": "ISC" }, "node_modules/yargs": { "version": "7.1.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.2.tgz", + "resolved": "https://registry.npmmirror.com/yargs/-/yargs-7.1.2.tgz", "integrity": "sha512-ZEjj/dQYQy0Zx0lgLMLR8QuaqTihnxirir7EwUHp1Axq4e3+k8jXU5K0VLbNvedv1f4EWtBonDIZm0NUr+jCcA==", "dev": true, "license": "MIT", @@ -17035,7 +16671,7 @@ }, "node_modules/yargs-parser": { "version": "20.2.4", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-20.2.4.tgz", "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", "dev": true, "license": "ISC", @@ -17045,7 +16681,7 @@ }, "node_modules/yargs-unparser": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "resolved": "https://registry.npmmirror.com/yargs-unparser/-/yargs-unparser-2.0.0.tgz", "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", "dev": true, "license": "MIT", @@ -17061,7 +16697,7 @@ }, "node_modules/yargs-unparser/node_modules/camelcase": { "version": "6.3.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-6.3.0.tgz", "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", "dev": true, "license": "MIT", @@ -17074,7 +16710,7 @@ }, "node_modules/yargs-unparser/node_modules/decamelize": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "resolved": "https://registry.npmmirror.com/decamelize/-/decamelize-4.0.0.tgz", "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", "dev": true, "license": "MIT", @@ -17087,7 +16723,7 @@ }, "node_modules/yargs/node_modules/ansi-regex": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-2.1.1.tgz", "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==", "dev": true, "license": "MIT", @@ -17097,7 +16733,7 @@ }, "node_modules/yargs/node_modules/is-fullwidth-code-point": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", "integrity": "sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==", "dev": true, "license": "MIT", @@ -17110,7 +16746,7 @@ }, "node_modules/yargs/node_modules/string-width": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "resolved": "https://registry.npmmirror.com/string-width/-/string-width-1.0.2.tgz", "integrity": "sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==", "dev": true, "license": "MIT", @@ -17125,7 +16761,7 @@ }, "node_modules/yargs/node_modules/strip-ansi": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==", "dev": true, "license": "MIT", @@ -17138,7 +16774,7 @@ }, "node_modules/yargs/node_modules/yargs-parser": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.1.tgz", + "resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-5.0.1.tgz", "integrity": "sha512-wpav5XYiddjXxirPoCTUPbqM0PXvJ9hiBMvuJgInvo4/lAOTZzUprArw17q2O1P2+GHhbBr18/iQwjL5Z9BqfA==", "dev": true, "license": "ISC", @@ -17149,7 +16785,7 @@ }, "node_modules/yocto-queue": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "resolved": "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, "license": "MIT", From d36dbefac4cc44d7be916423aa259cadf7bb6f18 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Wed, 6 May 2026 21:48:46 +0800 Subject: [PATCH 4/6] sync: drop internal egg/chair benchmark artifacts - Remove test/javascript/test-egg-benchmark.ts - Remove test/javascript/expect/chairbenchmark-expect.result - Drop test-egg script and its reference from test-all --- package.json | 3 +- .../expect/chairbenchmark-expect.result | 1119 ----------------- test/javascript/test-egg-benchmark.ts | 203 --- 3 files changed, 1 insertion(+), 1324 deletions(-) delete mode 100644 test/javascript/expect/chairbenchmark-expect.result delete mode 100644 test/javascript/test-egg-benchmark.ts diff --git a/package.json b/package.json index 47713ee6..ef37bb45 100644 --- a/package.json +++ b/package.json @@ -85,7 +85,6 @@ }, "scripts": { "test-js": "npx mocha --require tsx/cjs test/javascript/test-js-benchmark.ts", - "test-egg": "npx mocha --require tsx/cjs test/javascript/test-egg-benchmark.ts", "test-java": "npx mocha --require tsx/cjs test/java/test-java-benchmark.ts", "test-go": "npx mocha --require tsx/cjs test/go/test-go-benchmark.ts", "test-python": "npx mocha --require tsx/cjs test/python/test-python-benchmark.ts", @@ -95,7 +94,7 @@ "test-sink-util-new-expr": "npx mocha --require tsx/cjs test/rules-basic-handler/test-sink-util-new-expr.ts", "test-php-checker": "npx mocha --require tsx/cjs test/php/test-php-checker.ts", "test-php": "npx mocha --require tsx/cjs test/php/test-php-benchmark.ts", - "test-all": "npm run test-callargs && npm run test-match-field && npm run test-sink-util-new-expr && npm run test-js && npm run test-egg && npm run test-java && npm run test-go && npm run test-python && npm run test-callchain && npm run test-php", + "test-all": "npm run test-callargs && npm run test-match-field && npm run test-sink-util-new-expr && npm run test-js && npm run test-java && npm run test-go && npm run test-python && npm run test-callchain && npm run test-php", "build": "bash build.sh", "lint": "eslint .", "lint:duplicates": "jscpd .", diff --git a/test/javascript/expect/chairbenchmark-expect.result b/test/javascript/expect/chairbenchmark-expect.result deleted file mode 100644 index a183510f..00000000 --- a/test/javascript/expect/chairbenchmark-expect.result +++ /dev/null @@ -1,1119 +0,0 @@ -======================== Findings ======================== - -------------- 1: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrf_app_rpcAndGet_ts.ts -Line 6: this.ctx.curl(aa) -SINK RULE:this.ctx.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrf_app_rpcAndGet_ts.ts","functionName":"testSsrf","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrf_app_rpcAndGet_ts.ts - AffectedNodeName: aa - 5: SOURCE: async testSsrf(aa) { - /app/controller/ssrf_app_rpcAndGet_ts.ts - AffectedNodeName: this.ctx.curl - 6: SINK: const result = await this.ctx.curl(aa); - -------------- 2: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/level_test_2.ts -Line [22, 25]: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({with(genBaseParams(ctx)), with(params)}) -SINK RULE:ctx.oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"count_day","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: params - 19: SOURCE: params: any, - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay - 22: SINK: const res = await oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({ - 23: SINK: ...genBaseParams(ctx), - 24: SINK: ...params, - 25: SINK: }); - -------------- 3: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/level_test_2.ts -Line [22, 25]: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({with(genBaseParams(ctx)), with(params)}) -SINK RULE:ctx.oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"count_day","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: user.userId - 8: SOURCE: operatorId: user?.userId || '', - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: - 23: CALL RETURN: ...genBaseParams(ctx), - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay - 22: SINK: const res = await oneapi.insagentprod.AgentToDoQueryFacade.countAnchorDay({ - 23: SINK: ...genBaseParams(ctx), - 24: SINK: ...params, - 25: SINK: }); - -------------- 4: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/LevelParamSelf2.js -Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) -SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/LevelParamSelf2.js","functionName":"paramself","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: instId - 4: SOURCE: async paramself(advisorId,instId) { - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: req - 5: Var Pass: const req = { - 6: Var Pass: instId, - 7: Var Pass: advisorId, - 8: Var Pass: }; - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList - 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); - -------------- 5: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/LevelParamSelf2.js -Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) -SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/LevelParamSelf2.js","functionName":"paramself","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: advisorId - 4: SOURCE: async paramself(advisorId,instId) { - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: req - 5: Var Pass: const req = { - 6: Var Pass: instId, - 7: Var Pass: advisorId, - 8: Var Pass: }; - /app/controller/Level_test/LevelParamSelf2.js - AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList - 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); - -------------- 6: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/LevelParamSelf3.js -Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) -SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/LevelParamSelf3.js","functionName":"paramself3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: instId - 4: SOURCE: async paramself3(advisorId: any,instId: any) { - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: req - 5: Var Pass: const req = { - 6: Var Pass: instId, - 7: Var Pass: advisorId, - 8: Var Pass: }; - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList - 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); - -------------- 7: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/LevelParamSelf3.js -Line 9: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) -SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/LevelParamSelf3.js","functionName":"paramself3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: advisorId - 4: SOURCE: async paramself3(advisorId: any,instId: any) { - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: req - 5: Var Pass: const req = { - 6: Var Pass: instId, - 7: Var Pass: advisorId, - 8: Var Pass: }; - /app/controller/Level_test/LevelParamSelf3.js - AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList - 9: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); - -------------- 8: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/level_test_2.ts -Line 37: this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo(req) -SINK RULE:this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/level_test_2.ts","functionName":"getAdvisorReservoirManagementInfo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: this.ctx.request - 35: SOURCE: ...this.ctx.request.query - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: req - 34: Var Pass: const req = { - 35: Var Pass: ...this.ctx.request.query - 36: Var Pass: }; - /app/controller/Level_test/level_test_2.ts - AffectedNodeName: this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo - 37: SINK: const res = await this.ctx.proxy.AdvisorReservoirManagementFacade.getAdvisorReservoirManagementInfo(req); - -------------- 9: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/level_test_3.ts -Line 11: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req) -SINK RULE:this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/level_test_3.ts","functionName":"queryAdvisorRankListFacade","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/level_test_3.ts - AffectedNodeName: this.ctx.request - 7: SOURCE: ...this.ctx.request.body, - /app/controller/Level_test/level_test_3.ts - AffectedNodeName: req - 6: Var Pass: const req = { - 7: Var Pass: ...this.ctx.request.body, - 8: Var Pass: instId, - 9: Var Pass: advisorId, - 10: Var Pass: }; - /app/controller/Level_test/level_test_3.ts - AffectedNodeName: this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList - 11: SINK: this.ctx.body = await this.ctx.proxy.AdvisorRankListFacade.queryAdvisorRankList(req); - -------------- 10: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrfHttp.ts -Line 17: this.ctx.curl(__ttt__) -SINK RULE:this.ctx.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrfHttp.ts","functionName":"testhttp","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrfHttp.ts - AffectedNodeName: this.ctx.request - 15: SOURCE: const { abc } = this.ctx.request; - /app/controller/ssrfHttp.ts - AffectedNodeName: abc - 15: Var Pass: const { abc } = this.ctx.request; - /app/controller/ssrfHttp.ts - AffectedNodeName: __ttt__ - 16: Var Pass: const { __ttt__ } = abc; - /app/controller/ssrfHttp.ts - AffectedNodeName: this.ctx.curl - 17: SINK: const a = await this.ctx.curl(__ttt__); - -------------- 11: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrfHttp.ts -Line 22: this.app.curl(this.ctx.params) -SINK RULE:this.app.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrfHttp.ts","functionName":"testhttp3","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrfHttp.ts - AffectedNodeName: this.ctx.params - 22: SOURCE: const appCurl = await this.app.curl(this.ctx.params); - /app/controller/ssrfHttp.ts - AffectedNodeName: this.app.curl - 22: SINK: const appCurl = await this.app.curl(this.ctx.params); - -------------- 12: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/vm2Test.js -Line 7: new VM().run(a) -SINK RULE:vm2.VM.run -SINK Attribute:NodejsVm2Run -entrypoint: -{"filePath":"/app/controller/vm2Test.js","functionName":"testVm2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/vm2Test.js - AffectedNodeName: this.ctx.query - 6: SOURCE: const a= this.ctx.query.a; - /app/controller/vm2Test.js - AffectedNodeName: a - 6: Var Pass: const a= this.ctx.query.a; - /app/controller/vm2Test.js - AffectedNodeName: new VM().run - 7: SINK: new VM().run(a) - -------------- 13: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/iteratorNextTest.js -Line 11: it.next(this.ctx.query.a) -SINK RULE:dom-iterator.next -entrypoint: -{"filePath":"/app/controller/iteratorNextTest.js","functionName":"testNext","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/iteratorNextTest.js - AffectedNodeName: this.ctx.query - 11: SOURCE: while (next = it.next(this.ctx.query.a)) { } - /app/controller/iteratorNextTest.js - AffectedNodeName: it.next - 11: SINK: while (next = it.next(this.ctx.query.a)) { } - -------------- 14: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/vm2Test.js -Line 13: VMInstance.run(a) -SINK RULE:vm2.VM.run -SINK Attribute:NodejsVm2Run -entrypoint: -{"filePath":"/app/controller/vm2Test.js","functionName":"testVm21","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/vm2Test.js - AffectedNodeName: this.ctx.query - 11: SOURCE: const a = this.ctx.query.a; - /app/controller/vm2Test.js - AffectedNodeName: a - 11: Var Pass: const a = this.ctx.query.a; - /app/controller/vm2Test.js - AffectedNodeName: VMInstance.run - 13: SINK: VMInstance.run(a) - -------------- 15: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/mysql2Test.js -Line [20, 28]: conn.query(sql, function (var err:any, var result:any){{{conn.end(), if(err){{reject(err)}}, resolve(result)}}}) -SINK RULE:conn.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/mysql2Test.js","functionName":"test1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/mysql2Test.js - AffectedNodeName: sql - 16: SOURCE: async test1(sql) { - /app/controller/mysql2Test.js - AffectedNodeName: /app/controller/mysql2Test.mysql2Test.test1. - 19: CALL: return new Promise(function (resolve, reject) { - /app/controller/mysql2Test.js - AffectedNodeName: /app/controller/mysql2Test.mysql2Test.test1. - 19: ARG PASS: return new Promise(function (resolve, reject) { - /app/controller/mysql2Test.js - AffectedNodeName: conn.query - 20: SINK: conn.query(sql, function (err, result) { - 21: SINK: conn.end() - 22: SINK: - 23: SINK: if (err) { - 24: SINK: reject(err) - 25: SINK: } - 26: SINK: - 27: SINK: resolve(result) - 28: SINK: }) - -------------- 16: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/mysql2Test.js -Line [33, 39]: createConnection({user:config.user, password:config.password, host:config.host, port:config.port, database:config.database}).query(sql) -SINK RULE:mysql2.createConnection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/mysql2Test.js","functionName":"test2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/mysql2Test.js - AffectedNodeName: sql - 32: SOURCE: async test2(sql) { - /app/controller/mysql2Test.js - AffectedNodeName: createConnection({user:config.user, password:config.password, host:config.host, port:config.port, database:config.database}).query - 33: SINK: return createConnection({ - 34: SINK: user: config.user, - 35: SINK: password: config.password, - 36: SINK: host: config.host, - 37: SINK: port: config.port, - 38: SINK: database: config.database - 39: SINK: }).query(sql) - -------------- 17: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/File.js -Line 51: require(ssh2-sftp-client).get(Path) -SINK RULE:ssh2-sftp-client.get -SINK Attribute:NodejsFileOperator -entrypoint: -{"filePath":"/app/controller/File.js","functionName":"upload2SftpWhite2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/File.js - AffectedNodeName: this.ctx.request - 32: SOURCE: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: path - 32: Var Pass: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: fileName - 36: Var Pass: const fileName = path; - /app/controller/File.js - AffectedNodeName: Path - 40: Var Pass: const Path = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; - /app/controller/File.js - AffectedNodeName: require(ssh2-sftp-client).get - 51: SINK: await require('ssh2-sftp-client').get(Path); - -------------- 18: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/File.js -Line 74: sftp.put(stream, ossPath) -SINK RULE:ssh2-sftp-client.put -SINK Attribute:NodejsFileOperator -entrypoint: -{"filePath":"/app/controller/File.js","functionName":"upload2SftpBlack","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/File.js - AffectedNodeName: this.ctx.request - 61: SOURCE: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: path - 61: Var Pass: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: fileName - 66: Var Pass: const fileName = path; - /app/controller/File.js - AffectedNodeName: ossPath - 70: Var Pass: const ossPath = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; - /app/controller/File.js - AffectedNodeName: sftp.put - 74: SINK: await sftp.put(stream, ossPath); - -------------- 19: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/File.js -Line 97: require(ssh2-sftp-client).get(ossPath) -SINK RULE:ssh2-sftp-client.get -SINK Attribute:NodejsFileOperator -entrypoint: -{"filePath":"/app/controller/File.js","functionName":"upload2SftpBlack2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/File.js - AffectedNodeName: this.ctx.request - 86: SOURCE: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: path - 86: Var Pass: const { path } = this.ctx.request; - /app/controller/File.js - AffectedNodeName: fileName - 89: Var Pass: const fileName = path; - /app/controller/File.js - AffectedNodeName: ossPath - 93: Var Pass: const ossPath = `${bizType}/${instId}/creditmng/${moment().format('YYYYMMDD')}/${uuid()}/${fileName}`; - /app/controller/File.js - AffectedNodeName: require(ssh2-sftp-client).get - 97: SINK: await require('ssh2-sftp-client').get(ossPath); - -------------- 20: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 8: this.ctx.app.mysql.query(queryStr) -SINK RULE:this.ctx.app.mysql.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggMysqlBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 5: SOURCE: async eggMysqlBlack1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 6: Var Pass: let sqlString = ` - 7: Var Pass: SELECT uk_cluster_name,cluster_type - 8: Var Pass: FROM cluster - 9: Var Pass: WHERE uk_cluster_name LIKE '%${fuzzyStr}%' - 10: Var Pass: ` - /app/controller/sqlEggMysql.js - AffectedNodeName: query - 11: CALL: let result = await ctx.service.sql.query(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 6: ARG PASS: async query(queryStr) { - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.query. - 8: CALL: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.query. - 8: ARG PASS: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: this.ctx.app.mysql.query - 8: SINK: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - -------------- 21: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 13: connection.query(queryStr) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 23: SOURCE: async eggConnBlack1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 24: Var Pass: let sqlString = "UPDATE posts SET title = "+ fuzzyStr - /app/controller/sqlEggMysql.js - AffectedNodeName: connQuery - 25: CALL: let result = await this.ctx.service.sql.connQuery(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 11: ARG PASS: async connQuery(queryStr){ - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.connQuery. - 13: CALL: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.connQuery. - 13: ARG PASS: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: connection.query - 13: SINK: const record = await co(function * () { return yield connection.query(queryStr) }) - -------------- 22: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 14: connection.query(queryStr) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnBlack1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 23: SOURCE: async eggConnBlack1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 24: Var Pass: let sqlString = "UPDATE posts SET title = "+ fuzzyStr - /app/controller/sqlEggMysql.js - AffectedNodeName: connQuery - 25: CALL: let result = await this.ctx.service.sql.connQuery(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 11: ARG PASS: async connQuery(queryStr){ - /app/service/sql.js - AffectedNodeName: [return value] - 13: Return Value: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: - 13: CALL RETURN: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: record - 13: Var Pass: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: connection.query - 14: SINK: const res = connection.query(queryStr); - -------------- 23: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 8: this.ctx.app.mysql.query(queryStr) -SINK RULE:this.ctx.app.mysql.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggMysqlWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 14: SOURCE: async eggMysqlWhite1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 15: Var Pass: let sqlString = ` - 16: Var Pass: SELECT uk_cluster_name,cluster_type - 17: Var Pass: FROM cluster - 18: Var Pass: WHERE uk_cluster_name LIKE '%${mysql.escape(fuzzyStr)}%' - 19: Var Pass: ` - /app/controller/sqlEggMysql.js - AffectedNodeName: query - 20: CALL: let result = await ctx.service.sql.query(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 6: ARG PASS: async query(queryStr) { - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.query. - 8: CALL: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.query. - 8: ARG PASS: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: this.ctx.app.mysql.query - 8: SINK: const record = await co(function * () { return yield this.ctx.app.mysql.query(queryStr) }) - -------------- 24: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 13: connection.query(queryStr) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 27: SOURCE: async eggConnWhite1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 28: Var Pass: let sqlString = "UPDATE posts SET title = "+ mysql.escape(fuzzyStr) - /app/controller/sqlEggMysql.js - AffectedNodeName: connQuery - 29: CALL: let result = await ctx.service.sql.connQuery(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 11: ARG PASS: async connQuery(queryStr){ - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.connQuery. - 13: CALL: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: /app/service/sql.Sql.connQuery. - 13: ARG PASS: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: connection.query - 13: SINK: const record = await co(function * () { return yield connection.query(queryStr) }) - -------------- 25: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/service/sql.js -Line 14: connection.query(queryStr) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite1","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 27: SOURCE: async eggConnWhite1(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: sqlString - 28: Var Pass: let sqlString = "UPDATE posts SET title = "+ mysql.escape(fuzzyStr) - /app/controller/sqlEggMysql.js - AffectedNodeName: connQuery - 29: CALL: let result = await ctx.service.sql.connQuery(sqlString) - /app/service/sql.js - AffectedNodeName: queryStr - 11: ARG PASS: async connQuery(queryStr){ - /app/service/sql.js - AffectedNodeName: [return value] - 13: Return Value: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: - 13: CALL RETURN: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: record - 13: Var Pass: const record = await co(function * () { return yield connection.query(queryStr) }) - /app/service/sql.js - AffectedNodeName: connection.query - 14: SINK: const res = connection.query(queryStr); - -------------- 26: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/sqlEggMysql.js -Line 33: connection.query(mysql.escape(fuzzyStr)) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqlEggMysql.js","functionName":"eggConnWhite2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqlEggMysql.js - AffectedNodeName: fuzzyStr - 31: SOURCE: async eggConnWhite2(fuzzyStr) { - /app/controller/sqlEggMysql.js - AffectedNodeName: /app/controller/sqlEggMysql.SqlEggMysql.eggConnWhite2. - 33: CALL: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) - /app/controller/sqlEggMysql.js - AffectedNodeName: /app/controller/sqlEggMysql.SqlEggMysql.eggConnWhite2. - 33: ARG PASS: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) - /app/controller/sqlEggMysql.js - AffectedNodeName: connection.query - 33: SINK: const record = await co(function * () { return yield connection.query(mysql.escape(fuzzyStr)) }) - -------------- 27: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/VariableCover/variable_cover_3.js -Line 23: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/VariableCover/variable_cover_3.js","functionName":"echo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: ctx.userId - 17: SOURCE: const { uid } = ctx.userId; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: uid - 17: Var Pass: const { uid } = ctx.userId; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: newParmas - 19: Var Pass: const newParmas = { - 20: Var Pass: uid, - 21: Var Pass: ...params, - 22: Var Pass: }; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 23: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas); - -------------- 28: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/VariableCover/variable_cover_3.js -Line 23: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/VariableCover/variable_cover_3.js","functionName":"echo","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: ctx.request - 18: SOURCE: const params = ctx.request.body; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: params - 18: Var Pass: const params = ctx.request.body; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: newParmas - 19: Var Pass: const newParmas = { - 20: Var Pass: uid, - 21: Var Pass: ...params, - 22: Var Pass: }; - /app/controller/VariableCover/variable_cover_3.js - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 23: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(newParmas); - -------------- 29: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrfHttpTwo.js -Line 13: this.app.curl(this.ctx.params) -SINK RULE:this.app.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrfHttpTwo.js","functionName":"testAppSsrf2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrfHttpTwo.js - AffectedNodeName: this.ctx.params - 13: SOURCE: const appCurl = await this.app.curl(this.ctx.params); - /app/controller/ssrfHttpTwo.js - AffectedNodeName: this.app.curl - 13: SINK: const appCurl = await this.app.curl(this.ctx.params); - -------------- 30: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrfHttpTwo.js -Line 7: bb.curl(this.ctx.request) -SINK RULE:this.ctx.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrfHttpTwo.js","functionName":"testSsrf2","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrfHttpTwo.js - AffectedNodeName: this.ctx.request - 7: SOURCE: const a = await bb.curl(this.ctx.request); - /app/controller/ssrfHttpTwo.js - AffectedNodeName: bb.curl - 7: SINK: const a = await bb.curl(this.ctx.request); - -------------- 31: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/module_deserialize_directly_call.js -Line 14: require(node-serialize).unserialize(str) -SINK RULE:node-serialize.unserialize -SINK Attribute:NodejsModuleDeserialize -entrypoint: -{"filePath":"/app/controller/module_deserialize_directly_call.js","functionName":"moduleDeserializeTest","attribute":"HTTP","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/module_deserialize_directly_call.js - AffectedNodeName: ctx.request - 13: SOURCE: const str = ctx.request.cookies.profile; - /app/controller/module_deserialize_directly_call.js - AffectedNodeName: str - 13: Var Pass: const str = ctx.request.cookies.profile; - /app/controller/module_deserialize_directly_call.js - AffectedNodeName: require(node-serialize).unserialize - 14: SINK: const obj = require('node-serialize').unserialize(str); - -------------- 32: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/cmd_mgw_ts.ts -Line 14: eval(ctx.request.a) -SINK RULE:eval -SINK Attribute:NodejsExec -entrypoint: -{"filePath":"/app/controller/cmd_mgw_ts.ts","functionName":"eval_mgw","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/cmd_mgw_ts.ts - AffectedNodeName: ctx.request - 14: SOURCE: const res = eval(ctx.request.a); - /app/controller/cmd_mgw_ts.ts - AffectedNodeName: eval - 14: SINK: const res = eval(ctx.request.a); - -------------- 33: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/LevelParamSelf4.js -Line 12: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/LevelParamSelf4.js","functionName":"lps4","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/LevelParamSelf4.js - AffectedNodeName: params - 10: SOURCE: params: { cardNo: string }, - /app/controller/Level_test/LevelParamSelf4.js - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 12: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo); - -------------- 34: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/Level_test.ts -Line 12: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/Level_test.ts","functionName":"hasHistRepayRecord","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/Level_test.ts - AffectedNodeName: params - 10: SOURCE: params: { cardNo: string }, - /app/controller/Level_test/Level_test.ts - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 12: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(params.cardNo); - -------------- 35: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/Level_test/level_test_4.ts -Line 9: this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum(trParams) -SINK RULE:this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/Level_test/level_test_4.ts","functionName":"rpc_level_test_4","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/Level_test/level_test_4.ts - AffectedNodeName: params - 5: SOURCE: async rpc_level_test_4(params: any) { // 224621 - /app/controller/Level_test/level_test_4.ts - AffectedNodeName: trParams - 6: Var Pass: const trParams = { - 7: Var Pass: ...params, - 8: Var Pass: }; - /app/controller/Level_test/level_test_4.ts - AffectedNodeName: this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum - 9: SINK: const result = await this.ctx.proxy.certificateSendOrderQueryFacade.countAvailableNum(trParams); - -------------- 36: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/mgw.ts -Line 27: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/mgw.ts","functionName":"hello","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/mgw.ts - AffectedNodeName: ctx.userId - 23: SOURCE: siteUserId: ctx.userId,//mmm - /app/controller/mgw.ts - AffectedNodeName: queryParams - 22: Var Pass: const queryParams = { - 23: Var Pass: siteUserId: ctx.userId,//mmm - 24: Var Pass: ...params, - 25: Var Pass: - 26: Var Pass: }; - /app/controller/mgw.ts - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 27: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); - -------------- 37: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/mgw.ts -Line 27: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/mgw.ts","functionName":"hello","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/mgw.ts - AffectedNodeName: params - 20: SOURCE: params: { cardNo: string }, - /app/controller/mgw.ts - AffectedNodeName: queryParams - 22: Var Pass: const queryParams = { - 23: Var Pass: siteUserId: ctx.userId,//mmm - 24: Var Pass: ...params, - 25: Var Pass: - 26: Var Pass: }; - /app/controller/mgw.ts - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 27: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); - -------------- 38: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/module_deserialize_mrpc_directly_call.js -Line 12: require(node-serialize).unserialize(str) -SINK RULE:node-serialize.unserialize -SINK Attribute:NodejsModuleDeserialize -entrypoint: -{"filePath":"/app/controller/module_deserialize_mrpc_directly_call.js","functionName":"moduleDeserializeMrpcTest","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/module_deserialize_mrpc_directly_call.js - AffectedNodeName: ctx.request - 11: SOURCE: const str = ctx.request.cookies.profile; - /app/controller/module_deserialize_mrpc_directly_call.js - AffectedNodeName: str - 11: Var Pass: const str = ctx.request.cookies.profile; - /app/controller/module_deserialize_mrpc_directly_call.js - AffectedNodeName: require(node-serialize).unserialize - 12: SINK: const obj = require('node-serialize').unserialize(str); - -------------- 39: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/sqli_app_rpc_ts.ts -Line [10, 12]: connection.query(SELECT * FROM projects WHERE id =+this.ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sqli_app_rpc_ts.ts","functionName":"sqli_controller","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sqli_app_rpc_ts.ts - AffectedNodeName: this.ctx.request - 10: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { - /app/controller/sqli_app_rpc_ts.ts - AffectedNodeName: connection.query - 10: SINK: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { - 11: SINK: if (err) throw err; - 12: SINK: }); - -------------- 40: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/sql_mgw_ts.ts -Line [23, 25]: connection.query(SELECT * FROM projects WHERE id =+ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/controller/sql_mgw_ts.ts","functionName":"sql_mgw","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/sql_mgw_ts.ts - AffectedNodeName: ctx.request - 23: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + ctx.request.body.data, function (err) { - /app/controller/sql_mgw_ts.ts - AffectedNodeName: connection.query - 23: SINK: connection.query('SELECT * FROM projects WHERE id =' + ctx.request.body.data, function (err) { - 24: SINK: if (err) throw err; - 25: SINK: }); - -------------- 41: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/ssrf_app_rpcAndGet_ts.ts -Line 6: this.ctx.curl(aa) -SINK RULE:this.ctx.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/controller/ssrf_app_rpcAndGet_ts.ts","functionName":"testSsrf","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/ssrf_app_rpcAndGet_ts.ts - AffectedNodeName: aa - 5: SOURCE: async testSsrf(aa) { - /app/controller/ssrf_app_rpcAndGet_ts.ts - AffectedNodeName: this.ctx.curl - 6: SINK: const result = await this.ctx.curl(aa); - -------------- 42: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/VariableCover/variable_cover_2.js -Line 17: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/VariableCover/variable_cover_2.js","functionName":"hhhh","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: ctx.userId - 13: SOURCE: siteUserId: ctx.userId,//mmm - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: queryParams - 12: Var Pass: const queryParams = { - 13: Var Pass: siteUserId: ctx.userId,//mmm - 14: Var Pass: ...params, - 15: Var Pass: - 16: Var Pass: }; - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 17: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); - -------------- 43: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/controller/VariableCover/variable_cover_2.js -Line 17: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams) -SINK RULE:ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord -SINK Attribute:NodejsLevelAuthority -entrypoint: -{"filePath":"/app/controller/VariableCover/variable_cover_2.js","functionName":"hhhh","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: params - 10: SOURCE: params: { cardNo: string }, - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: queryParams - 12: Var Pass: const queryParams = { - 13: Var Pass: siteUserId: ctx.userId,//mmm - 14: Var Pass: ...params, - 15: Var Pass: - 16: Var Pass: }; - /app/controller/VariableCover/variable_cover_2.js - AffectedNodeName: ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord - 17: SINK: const result = await ctx.oneapi.ccrprod.repayBillQueryFacade.hasHistRepayRecord(queryParams); - -------------- 44: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/cmd_twa_js.js -Line [19, 24]: childProcess.exec(this.ctx.request.body.cmd, function (var error:any, var stdout:any, var stderr:any){{{if(error){{reject(error)}}, resolve(stdout)}}}) -SINK RULE:child_process.exec -SINK Attribute:NodejsExec -entrypoint: -{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval01_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/cmd_twa_js.js - AffectedNodeName: this.ctx.request - 19: SOURCE: childProcess.exec(this.ctx.request.body.cmd, (error, stdout, stderr) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval01_twa. - 18: CALL: const body = await new Promise((resolve, reject) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval01_twa. - 18: ARG PASS: const body = await new Promise((resolve, reject) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: childProcess.exec - 19: SINK: childProcess.exec(this.ctx.request.body.cmd, (error, stdout, stderr) => { - 20: SINK: if (error) { - 21: SINK: reject(error); - 22: SINK: } - 23: SINK: resolve(stdout); - 24: SINK: }); - -------------- 45: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/cmd_twa_js.js -Line [38, 43]: require(child_process).spawn(this.ctx.request.body.cmd, function (var error:any, var stdout:any, var stderr:any){{{if(error){{reject(error)}}, resolve(stdout)}}}) -SINK RULE:child_process.spawn -SINK Attribute:NodejsExec -entrypoint: -{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval02_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/cmd_twa_js.js - AffectedNodeName: this.ctx.request - 38: SOURCE: require('child_process').spawn(this.ctx.request.body.cmd, (error, stdout, stderr) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval02_twa. - 37: CALL: const body = await new Promise((resolve, reject) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: /app/rpc/cmd_twa_js.Cmd_one.eval02_twa. - 37: ARG PASS: const body = await new Promise((resolve, reject) => { - /app/rpc/cmd_twa_js.js - AffectedNodeName: require(child_process).spawn - 38: SINK: require('child_process').spawn(this.ctx.request.body.cmd, (error, stdout, stderr) => { - 39: SINK: if (error) { - 40: SINK: reject(error); - 41: SINK: } - 42: SINK: resolve(stdout); - 43: SINK: }); - -------------- 46: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/cmd_twa_js.js -Line 6: eval(this.ctx.request.body.cmd) -SINK RULE:eval -SINK Attribute:NodejsExec -entrypoint: -{"filePath":"/app/rpc/cmd_twa_js.js","functionName":"eval_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/cmd_twa_js.js - AffectedNodeName: this.ctx.request - 6: SOURCE: const body = eval(this.ctx.request.body.cmd); - /app/rpc/cmd_twa_js.js - AffectedNodeName: eval - 6: SINK: const body = eval(this.ctx.request.body.cmd); - -------------- 47: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/sql_twa_js.js -Line [15, 17]: connection.query(SELECT * FROM projects WHERE id =+this.ctx.request.body.data, function (var err:any){{{if(err){throw err}}}}}) -SINK RULE:connection.query -SINK Attribute:NodejsSqlInjection -entrypoint: -{"filePath":"/app/rpc/sql_twa_js.js","functionName":"sql_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/sql_twa_js.js - AffectedNodeName: this.ctx.request - 15: SOURCE: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { - /app/rpc/sql_twa_js.js - AffectedNodeName: connection.query - 15: SINK: connection.query('SELECT * FROM projects WHERE id =' + this.ctx.request.body.data, function (err) { - 16: SINK: if (err) throw err; - 17: SINK: }); - -------------- 48: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/ssrf_twa_js.js -Line 23: this.app.curl(this.ctx.request.query.url) -SINK RULE:this.app.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"getProxy01_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/ssrf_twa_js.js - AffectedNodeName: this.ctx.request - 23: SOURCE: const result = await this.app.curl(this.ctx.request.query.url); - /app/rpc/ssrf_twa_js.js - AffectedNodeName: this.app.curl - 23: SINK: const result = await this.app.curl(this.ctx.request.query.url); - -------------- 49: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/ssrf_twa_js.js -Line 36: ctx.service.xdevapi.curl(url) -SINK RULE:this.app.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"getProxy02_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/ssrf_twa_js.js - AffectedNodeName: ctx.query - 35: SOURCE: const { url } = ctx.query; - /app/rpc/ssrf_twa_js.js - AffectedNodeName: url - 35: Var Pass: const { url } = ctx.query; - /app/rpc/ssrf_twa_js.js - AffectedNodeName: ctx.service.xdevapi.curl - 36: SINK: const result = await ctx.service.xdevapi.curl(url); - -------------- 50: taint_flow_egg_input------------- -Description:JavaScript Egg框架污点分析checker -File:/app/rpc/ssrf_twa_js.js -Line [13, 18]: this.ctx.curl(url_test, {headers:{bakery-token:this.ctx.extraConfig.BAKERY_SPM_TOKEN}, data:this.ctx.query}) -SINK RULE:this.ctx.curl -SINK Attribute:NodejsSSRF -entrypoint: -{"filePath":"/app/rpc/ssrf_twa_js.js","functionName":"ssrf_twa","attribute":"MRPC","type":"functionCall","funcReceiverType":""} -Trace: - /app/rpc/ssrf_twa_js.js - AffectedNodeName: test_a - 5: SOURCE: async ssrf_twa(test_a) { - /app/rpc/ssrf_twa_js.js - AffectedNodeName: UrlReq - 6: Var Pass: const UrlReq = { - 7: Var Pass: url: test_a, - 8: Var Pass: userId: this.ctx.userId, - 9: Var Pass: }; - /app/rpc/ssrf_twa_js.js - AffectedNodeName: url_test - 12: Var Pass: const url_test = UrlReq.url; - /app/rpc/ssrf_twa_js.js - AffectedNodeName: this.ctx.curl - 13: SINK: const res = await this.ctx.curl(url_test, { - 14: SINK: headers: { - 15: SINK: 'bakery-token': this.ctx.extraConfig.BAKERY_SPM_TOKEN, - 16: SINK: }, - 17: SINK: data: this.ctx.query, - 18: SINK: }); -========================================================== - #Total-findings:50 -========================================================== \ No newline at end of file diff --git a/test/javascript/test-egg-benchmark.ts b/test/javascript/test-egg-benchmark.ts deleted file mode 100644 index de189f8e..00000000 --- a/test/javascript/test-egg-benchmark.ts +++ /dev/null @@ -1,203 +0,0 @@ -import * as path from 'path' -import { describe, it } from 'mocha' -// @ts-ignore -import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' -const { execute } = require('../../src/interface/starter') -const { ErrorCode } = require('../../src/util/error-code') -const { - BENCHMARKS_DIR, - XAST_JS_BENCHMARK, - recordFindingStr, - readExpectRes, - resolveFindingResult, - getExpectResultPath, -} = require('../test-utils') -import * as assert from 'assert' -import * as fs from 'fs' -const RULE_CONFIG_PATH = 'rule_config.json' -const logger = require('../../src/util/logger')(__filename) -const { handleException } = require('../../src/engine/analyzer/common/exception-handler') -const fileUtil = require('../../src/util/file-util') - -async function regressionEggBenchmark(): Promise { - const benchmarkRootPath = path.resolve(__dirname, BENCHMARKS_DIR) - const benchmarkDir = fs.readdirSync(benchmarkRootPath) - for (const benchmarkPathItem of benchmarkDir) { - let filePath = path.join(benchmarkRootPath, benchmarkPathItem) - const fileStat = fs.lstatSync(filePath) - if (fileStat.isDirectory()) { - filePath = filePath + '/' - if (benchmarkPathItem !== XAST_JS_BENCHMARK) { - logger.info('execute test in ', filePath) - const result = await runEggBenchmark(filePath) - checkEggBenchmarkResult(result, filePath) - } - } - } -} - -async function runEggBenchmark(dir: string): Promise< - | { - expectedRes: any - actualRes: any - expectedResMap: Map - actualResMap: Map - accuracyStats: AccuracyStats | null - } - | undefined -> { - try { - const ruleConfigFile = path.join(path.resolve(dir), RULE_CONFIG_PATH) - const expectPath = getExpectResultPath(dir) - - const repoName = path.basename(dir) - const reportDir = path.join(__dirname, 'report', repoName) - let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map - let recorder = recordFindingStr() - recorder.clearResult() - - let args = [ - dir, - '--ruleConfigFile', - ruleConfigFile, - '--analyzer', - 'EggAnalyzer', - '--checkerPackIds', - 'taint-flow-javascript-inner', - '--report', - reportDir, - ] - - await execute(null, args, recorder.printAndAppend, false) - expectedRes = readExpectRes(expectPath) - actualRes = recorder.getFormatResult() - expectedResMap = resolveFindingResult(expectedRes) - actualResMap = resolveFindingResult(actualRes) - - // 计算 trace 准确率 - let accuracyStats: AccuracyStats | null = null - const sarifPath = path.join(reportDir, 'report.sarif') - if (fs.existsSync(sarifPath)) { - const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) - accuracyStats = computeAccuracyFromSarif(sarifData) - } - - return { - expectedRes, - actualRes, - expectedResMap, - actualResMap, - accuracyStats, - } - } catch (e) { - handleException(e, `ERROR in runEggBenchmark: ${e}`, `ERROR in runEggBenchmark: ${e}`) - process.exitCode = ErrorCode.unknown_error - } -} - -function checkEggBenchmarkResult( - result: - | { - expectedRes: any - actualRes: any - expectedResMap: Map - actualResMap: Map - accuracyStats: AccuracyStats | null - } - | undefined, - name: string -): void { - if (!result) return - - const description = `YASA test ${name.includes('chairbenchmark') ? 'chairBenchmark' : 'yasaNodeJsBenchmark'}` - describe(description, async function () { - this.timeout(10000) // 设置超时时间 - - it(`check result data directly`, async function () { - const { expectedRes, actualRes } = result - logger.info(actualRes) - assert.strictEqual(actualRes, expectedRes, '当前靶场扫描结果与历史预期不一致,请逐个核对链路') - }) - let i = 1 - const { expectedResMap, actualResMap } = result - expectedResMap.forEach((value, key) => { - it(`${i++}-entryPoint:${key}`, async function () { - logger.info('expected:\n' + value) - logger.info('actual:\n' + actualResMap.get(key)) - if (actualResMap.has(key)) { - assert.strictEqual(actualResMap.get(key), value, `链路${key}实际trace或内容与预期不一致，请核对该链路`) - } else { - assert.fail(`链路或key${key}不存在！！！`) - } - }) - }) - - const actualChains = Array.from(actualResMap.keys()) - let addChains = actualChains.filter((key) => !expectedResMap.has(key)) - if (Array.isArray(addChains) && addChains.length > 0) { - for (const addChain of addChains) { - it(`new chain:${addChain}`, function () { - logger.info(`新增检出${addChain},请核对新增检出内容是否符合预期`) - logger.info(actualResMap.get(addChain)) - assert.fail(`new chain:${addChain}`) - }) - } - } - - it(`trace accuracy`, function () { - const { accuracyStats } = result - if (!accuracyStats) { - this.skip() - return - } - const benchmarkName = name.includes('chairbenchmark') ? 'chairBenchmark' : 'yasaNodeJsBenchmark' - const pct = - accuracyStats.evaluableHops > 0 - ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) - : 'N/A' - logger.info( - `=== Trace Accuracy [${benchmarkName}]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` - ) - }) - }) -} - -async function updateBackup(dir: string): Promise { - const ruleConfigFile = path.join(path.resolve(dir), 'rule_config.json') - const repoName = path.basename(dir) - let actualRes: any - let recorder = recordFindingStr() - recorder.clearResult() - let args = [ - dir, - '--ruleConfigFile', - ruleConfigFile, - '--analyzer', - 'EggAnalyzer', - '--checkerPackIds', - 'taint-flow-javascript-inner', - ] - try { - await execute(null, args, recorder.printAndAppend, false) - } catch (e) { - handleException( - e, - `[test-egg-benchmark] 更新备份时发生错误，ERROR: ${e}`, - `[test-egg-benchmark] 更新备份时发生错误，ERROR: ${e}` - ) - recorder.clearResult() - process.exitCode = ErrorCode.unknown_error - } - actualRes = recorder.getFormatResult() - fs.writeFileSync(path.join(path.resolve(dir), '..', '..', 'expect', `${repoName}-expect.result`), actualRes, { - encoding: 'utf8', - }) -} - -regressionEggBenchmark() -// const benchmarkPath = fileUtil.getAbsolutePath('./test/javascript/benchmarks/yasaNodeJsBenchmark/') -// updateBackup(benchmarkPath) - -module.exports = { - regressionEggBenchmark, -} From 4efab0262aaf3c9cce984edff9727ebb20f3c0c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Wed, 6 May 2026 21:52:04 +0800 Subject: [PATCH 5/6] sync: drop internal benchmark URLs and absolute path in test harness - Restore prepare-js-benchmark.ts (remove two internal benchmark repo URLs) - Restore test-java-real-project.ts (remove hardcoded absolute path and experimental accuracy hook) --- test/java/test-java-real-project.ts | 35 ++----------------------- test/javascript/prepare-js-benchmark.ts | 8 ------ 2 files changed, 2 insertions(+), 41 deletions(-) diff --git a/test/java/test-java-real-project.ts b/test/java/test-java-real-project.ts index 42c853c0..868b289d 100644 --- a/test/java/test-java-real-project.ts +++ b/test/java/test-java-real-project.ts @@ -2,8 +2,6 @@ import path from 'path' import fs from 'fs' import { before, describe, it } from 'mocha' import assert from 'assert' -// @ts-ignore -import { computeAccuracyFromSarif, AccuracyStats } from '../trace-accuracy' const { execute } = require('../../src/interface/starter') const { handleException } = require('../../src/engine/analyzer/common/exception-handler') const { ErrorCode } = require('../../src/util/error-code') @@ -28,7 +26,6 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin let actualRes: any let expectedResMap: Map let actualResMap: Map - let accuracyStats: AccuracyStats | null = null let benchmarkReady = false before(async function () { @@ -37,7 +34,6 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin actualRes = result.actualRes expectedResMap = result.expectedResMap actualResMap = result.actualResMap - accuracyStats = result.accuracyStats benchmarkReady = true }) @@ -84,20 +80,6 @@ function runSingleProject(dir: string, ruleConfigFile: string, expectPath: strin assert.fail(`new chain:${addChains.length}`) } }) - - it(`trace accuracy`, function () { - if (!benchmarkReady || !accuracyStats) { - this.skip() - return - } - const pct = - accuracyStats.evaluableHops > 0 - ? ((accuracyStats.accurateHops / accuracyStats.evaluableHops) * 100).toFixed(2) - : 'N/A' - logger.info( - `=== Trace Accuracy [${repoName}]: ${pct}% (${accuracyStats.accurateHops}/${accuracyStats.evaluableHops} hops, ${accuracyStats.totalFindings} findings) ===` - ) - }) }) } @@ -121,10 +103,8 @@ async function getRunJavaBenchmarkResult( actualRes: any expectedResMap: Map actualResMap: Map - accuracyStats: AccuracyStats | null }> { const repoName = path.basename(dir) - const reportDir = path.join(__dirname, 'report', repoName) let expectedRes: any, actualRes: any, expectedResMap: Map, actualResMap: Map let recorder = recordFindingStr() @@ -140,8 +120,6 @@ async function getRunJavaBenchmarkResult( 'taint-flow-java-inner', '--entrypointMode', 'ONLY_CUSTOM', - '--report', - reportDir, ] await (async () => { try { @@ -162,20 +140,11 @@ async function getRunJavaBenchmarkResult( expectedResMap = resolveFindingResult(expectedRes) actualResMap = resolveFindingResult(actualRes) - // 计算 trace 准确率 - let accuracyStats: AccuracyStats | null = null - const sarifPath = path.join(reportDir, 'report.sarif') - if (fs.existsSync(sarifPath)) { - const sarifData = JSON.parse(fs.readFileSync(sarifPath, 'utf-8')) - accuracyStats = computeAccuracyFromSarif(sarifData) - } - return { expectedRes, actualRes, expectedResMap, actualResMap, - accuracyStats, } } @@ -212,8 +181,8 @@ async function updateExpect(dir: string, ruleConfigFile: string, expectPath: str }) } -const dir = '/Users/jiufo/yasaaaaa/Code-Regression-Real/Normal' -runMultiProject(dir) +// const dir = '' +// runMultiProject(dir) // const dir = '' // runSingleProject(dir, dir + '.json', dir + '.result') diff --git a/test/javascript/prepare-js-benchmark.ts b/test/javascript/prepare-js-benchmark.ts index c8b02942..5f187575 100644 --- a/test/javascript/prepare-js-benchmark.ts +++ b/test/javascript/prepare-js-benchmark.ts @@ -18,14 +18,6 @@ interface BenchmarkRepoUrls { } const JS_ALL_BENCHMARK_REPO_URLS: BenchmarkRepoUrls = { - yasaNodeJsBenchmark: { - gitRepoUrl: 'git@code.alipay.com:jiufo_test/yasaNodeJsBenchmark.git', - branch: 'master', - }, - chairbenchmark: { - gitRepoUrl: 'git@code.alipay.com:jiufo_test/chairbenchmark.git', - branch: 'master', - }, jsbenchmark: { gitRepoUrl: XAST_JS_BENCHMARK_REPO_URL, branch: 'main-forYasaTest', From 65f5fef59d5cf9f46371a44d8a747da15b15edab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=9D=E4=BD=9B?= Date: Thu, 7 May 2026 11:02:24 +0800 Subject: [PATCH 6/6] sync: update version --- src/util/constant.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/constant.ts b/src/util/constant.ts index c8fefe2f..05eb9812 100644 --- a/src/util/constant.ts +++ b/src/util/constant.ts @@ -7,7 +7,7 @@ export const ENGIN_START_FILE_BEGIN = 'fileBegin' export const YASA_DEFAULT = 'YASADefault' // 基础版本号 -const BASE_VERSION = '0.2.22-inner' +const BASE_VERSION = '0.3.1' /** * 尝试读取构建时生成的版本信息文件