@eggjs/security 4.0.0

package/dist/esm/lib/utils.js

@@ -0,0 +1,194 @@
+import { normalize } from 'node:path';
+import matcher from 'matcher';
+import IP from '@eggjs/ip';
+/**
+ * Check whether a domain is in the safe domain white list or not.
+ * @param {String} domain The inputted domain.
+ * @param {Array<string>} whiteList The white list for domain.
+ * @return {Boolean} If the `domain` is in the white list, return true; otherwise false.
+ */
+export function isSafeDomain(domain, whiteList) {
+    // domain must be string, otherwise return false
+    if (typeof domain !== 'string')
+        return false;
+    // Ignore case sensitive first
+    domain = domain.toLowerCase();
+    // add prefix `.`, because all domains in white list start with `.`
+    const hostname = '.' + domain;
+    return whiteList.some(rule => {
+        // Check whether we've got '*' as a wild character symbol
+        if (rule.includes('*')) {
+            return matcher.isMatch(domain, rule);
+        }
+        // If domain is an absolute path such as `http://...`
+        // We can directly check whether it directly equals to `domain`
+        // And we don't need to cope with `endWith`.
+        if (domain === rule)
+            return true;
+        // ensure wwweggjs.com not match eggjs.com
+        if (!/^\./.test(rule))
+            rule = `.${rule}`;
+        return hostname.endsWith(rule);
+    });
+}
+export function isSafePath(path, ctx) {
+    path = '.' + path;
+    if (path.includes('%')) {
+        try {
+            path = decodeURIComponent(path);
+        }
+        catch (e) {
+            if (ctx.app.config.env === 'local' || ctx.app.config.env === 'unittest') {
+                // not under production environment, output log
+                ctx.coreLogger.warn('[@eggjs/security: dta global block] : decode file path %j failed.', path);
+            }
+        }
+    }
+    const normalizePath = normalize(path);
+    return !(normalizePath.startsWith('../') || normalizePath.startsWith('..\\'));
+}
+export function checkIfIgnore(opts, ctx) {
+    // check opts.enable first
+    if (!opts.enable)
+        return true;
+    return !opts.matching?.(ctx);
+}
+const IP_RE = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const topDomains = {};
+[
+    '.net.cn', '.gov.cn', '.org.cn', '.com.cn',
+].forEach(item => {
+    topDomains[item] = 2 - item.split('.').length;
+});
+export function getCookieDomain(hostname) {
+    // TODO(fengmk2): support ipv6
+    if (IP_RE.test(hostname)) {
+        return hostname;
+    }
+    // app.test.domain.com => .test.domain.com
+    // app.stable.domain.com => .domain.com
+    // app.domain.com => .domain.com
+    // domain=.domain.com;
+    const splits = hostname.split('.');
+    let index = -2;
+    // only when `*.test.*.com` set `.test.*.com`
+    if (splits.length >= 4 && splits[splits.length - 3] === 'test') {
+        index = -3;
+    }
+    let domain = getDomain(splits, index);
+    if (topDomains[domain]) {
+        // app.foo.org.cn => .foo.org.cn
+        domain = getDomain(splits, index + topDomains[domain]);
+    }
+    return domain;
+}
+function getDomain(splits, index) {
+    return '.' + splits.slice(index).join('.');
+}
+export function merge(origin, opts) {
+    if (!opts) {
+        return origin;
+    }
+    const res = {};
+    const originKeys = Object.keys(origin);
+    for (let i = 0; i < originKeys.length; i++) {
+        const key = originKeys[i];
+        res[key] = origin[key];
+    }
+    const keys = Object.keys(opts);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        res[key] = opts[key];
+    }
+    return res;
+}
+export function preprocessConfig(config) {
+    // transfer ssrf.ipBlackList to ssrf.checkAddress
+    // ssrf.ipExceptionList can easily pick out unwanted ips from ipBlackList
+    // checkAddress has higher priority than ipBlackList
+    const ssrf = config.ssrf;
+    if (ssrf && ssrf.ipBlackList && !ssrf.checkAddress) {
+        const blackList = ssrf.ipBlackList.map(getContains);
+        const exceptionList = (ssrf.ipExceptionList || []).map(getContains);
+        const hostnameExceptionList = ssrf.hostnameExceptionList;
+        ssrf.checkAddress = (ipAddresses, _family, hostname) => {
+            // Check white hostname first
+            if (hostname && hostnameExceptionList) {
+                if (hostnameExceptionList.includes(hostname)) {
+                    return true;
+                }
+            }
+            // ipAddresses will be array address on Node.js >= 20
+            // [
+            //   { address: '220.181.125.241', family: 4 },
+            //   { address: '240e:964:ea02:b00:3::3ec', family: 6 }
+            // ]
+            if (!Array.isArray(ipAddresses)) {
+                ipAddresses = [ipAddresses];
+            }
+            for (const ipAddress of ipAddresses) {
+                let address;
+                if (typeof ipAddress === 'string') {
+                    address = ipAddress;
+                }
+                else {
+                    // FIXME: should support ipv6
+                    if (ipAddress.family === 6) {
+                        continue;
+                    }
+                    address = ipAddress.address;
+                }
+                // check white list first
+                for (const exception of exceptionList) {
+                    if (exception(address)) {
+                        return true;
+                    }
+                }
+                // check black list
+                for (const contains of blackList) {
+                    if (contains(address)) {
+                        return false;
+                    }
+                }
+            }
+            // default allow
+            return true;
+        };
+    }
+    // Make sure that `whiteList` or `protocolWhiteList` is case insensitive
+    config.domainWhiteList = config.domainWhiteList || [];
+    config.domainWhiteList = config.domainWhiteList.map((domain) => domain.toLowerCase());
+    config.protocolWhiteList = config.protocolWhiteList || [];
+    config.protocolWhiteList = config.protocolWhiteList.map((protocol) => protocol.toLowerCase());
+    // Make sure refererWhiteList is case insensitive
+    if (config.csrf && config.csrf.refererWhiteList) {
+        config.csrf.refererWhiteList = config.csrf.refererWhiteList.map((ref) => ref.toLowerCase());
+    }
+    // Directly converted to Set collection by a private property (not documented),
+    // And we NO LONGER need to do conversion in `foreach` again and again in `lib/helper/surl.ts`.
+    const protocolWhiteListSet = new Set(config.protocolWhiteList);
+    protocolWhiteListSet.add('http');
+    protocolWhiteListSet.add('https');
+    protocolWhiteListSet.add('file');
+    protocolWhiteListSet.add('data');
+    Object.defineProperty(config, '__protocolWhiteListSet', {
+        value: protocolWhiteListSet,
+        enumerable: false,
+    });
+}
+export function getFromUrl(url, prop) {
+    try {
+        const parsed = new URL(url);
+        return prop ? Reflect.get(parsed, prop) : parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function getContains(ip) {
+    if (IP.isV4Format(ip) || IP.isV6Format(ip)) {
+        return (address) => address === ip;
+    }
+    return IP.cidrSubnet(ip).contains;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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"}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,10 @@
+import './app/extend/application.js';
+import './app/extend/context.js';
+import type { SecurityConfig, SecurityHelperConfig } from './config/config.default.js';
+export type * from './config/config.default.js';
+declare module '@eggjs/core' {
+    interface EggAppConfig {
+        security: SecurityConfig;
+        helper: SecurityHelperConfig;
+    }
+}

package/dist/esm/types.js

@@ -0,0 +1,3 @@
+import './app/extend/application.js';
+import './app/extend/context.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLHlCQUF5QixDQUFDIn0=

package/dist/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@eggjs/security",
+  "version": "4.0.0"
+}

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@eggjs/security",
+  "version": "4.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "security plugin in egg framework",
+  "eggPlugin": {
+    "name": "security",
+    "optionalDependencies": [
+      "session"
+    ],
+    "exports": {
+      "import": "./dist/esm",
+      "require": "./dist/commonjs",
+      "typescript": "./src"
+    }
+  },
+  "keywords": [
+    "egg",
+    "eggPlugin",
+    "egg-plugin",
+    "security"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eggjs/security.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eggjs/egg/issues"
+  },
+  "homepage": "https://github.com/eggjs/security#readme",
+  "author": "jtyjty99999",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "dependencies": {
+    "@eggjs/core": "^6.2.13",
+    "@eggjs/ip": "^2.1.0",
+    "csrf": "^3.0.6",
+    "egg-path-matching": "^2.1.0",
+    "escape-html": "^1.0.3",
+    "extend": "^3.0.1",
+    "koa-compose": "^4.1.0",
+    "matcher": "^4.0.0",
+    "nanoid": "^3.3.8",
+    "type-is": "^1.6.18",
+    "xss": "^1.0.3",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.1",
+    "@eggjs/bin": "7",
+    "@eggjs/mock": "^6.0.5",
+    "@eggjs/supertest": "^8.2.0",
+    "@eggjs/tsconfig": "1",
+    "@types/escape-html": "^1.0.4",
+    "@types/extend": "^3.0.4",
+    "@types/koa-compose": "^3.2.8",
+    "@types/mocha": "10",
+    "@types/node": "22",
+    "@types/type-is": "^1.6.7",
+    "beautify-benchmark": "^0.2.4",
+    "benchmark": "^2.1.4",
+    "egg": "^4.0.1",
+    "egg-view-nunjucks": "^2.3.0",
+    "eslint": "8",
+    "eslint-config-egg": "14",
+    "rimraf": "6",
+    "snap-shot-it": "^7.9.10",
+    "spy": "^1.0.0",
+    "supertest": "^6.3.3",
+    "tshy": "3",
+    "tshy-after": "1",
+    "typescript": "5"
+  },
+  "scripts": {
+    "lint": "eslint --cache src test --ext .ts",
+    "pretest": "npm run clean && npm run lint -- --fix",
+    "test": "egg-bin test",
+    "test:snapshot:update": "SNAPSHOT_UPDATE=1 egg-bin test",
+    "preci": "npm run clean &&  npm run lint",
+    "ci": "egg-bin cov",
+    "postci": "npm run prepublishOnly && npm run clean",
+    "clean": "rimraf dist",
+    "prepublishOnly": "tshy && tshy-after && attw --pack"
+  },
+  "type": "module",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./package.json": "./package.json"
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js"
+}

package/src/agent.ts

@@ -0,0 +1,14 @@
+import type { ILifecycleBoot, EggCore } from '@eggjs/core';
+import { preprocessConfig } from './lib/utils.js';
+
+export default class AgentBoot implements ILifecycleBoot {
+  private readonly agent;
+
+  constructor(agent: EggCore) {
+    this.agent = agent;
+  }
+
+  async configWillLoad() {
+    preprocessConfig(this.agent.config.security);
+  }
+}

package/src/app/extend/agent.ts

@@ -0,0 +1,14 @@
+import { EggCore } from '@eggjs/core';
+import {
+  safeCurlForApplication,
+  type HttpClientRequestURL,
+  type HttpClientOptions,
+  type HttpClientResponse,
+} from '../../lib/extend/safe_curl.js';
+
+export default class SecurityAgent extends EggCore {
+  async safeCurl<T = any>(
+    url: HttpClientRequestURL, options?: HttpClientOptions): Promise<HttpClientResponse<T>> {
+    return await safeCurlForApplication<T>(this, url, options);
+  }
+}

package/src/app/extend/application.ts

@@ -0,0 +1,51 @@
+import { EggCore } from '@eggjs/core';
+import {
+  safeCurlForApplication,
+  type HttpClientRequestURL,
+  type HttpClientOptions,
+  type HttpClientResponse,
+} from '../../lib/extend/safe_curl.js';
+
+const INPUT_CSRF = '\r\n<input type="hidden" name="_csrf" value="{{ctx.csrf}}" /></form>';
+const INJECTION_DEFENSE = '<!--for injection--><!--</html>--><!--for injection-->';
+
+export default class SecurityApplication extends EggCore {
+  injectCsrf(html: string) {
+    html = html.replace(/(<form.*?>)([\s\S]*?)<\/form>/gi, (_, $1, $2) => {
+      const match = $2;
+      if (match.indexOf('name="_csrf"') !== -1 || match.indexOf('name=\'_csrf\'') !== -1) {
+        return $1 + match + '</form>';
+      }
+      return $1 + match + INPUT_CSRF;
+    });
+    return html;
+  }
+
+  injectNonce(html: string) {
+    html = html.replace(/<script(.*?)>([\s\S]*?)<\/script[^>]*?>/gi, (_, $1, $2) => {
+      if (!$1.includes('nonce=')) {
+        $1 += ' nonce="{{ctx.nonce}}"';
+      }
+      return '<script' + $1 + '>' + $2 + '</script>';
+    });
+    return html;
+  }
+
+  injectHijackingDefense(html: string) {
+    return INJECTION_DEFENSE + html + INJECTION_DEFENSE;
+  }
+
+  async safeCurl<T = any>(
+    url: HttpClientRequestURL, options?: HttpClientOptions): Promise<HttpClientResponse<T>> {
+    return await safeCurlForApplication<T>(this, url, options);
+  }
+}
+
+declare module '@eggjs/core' {
+  interface EggCore {
+    injectCsrf(html: string): string;
+    injectNonce(html: string): string;
+    injectHijackingDefense(html: string): string;
+    safeCurl<T = any>(url: HttpClientRequestURL, options?: HttpClientOptions): Promise<HttpClientResponse<T>>;
+  }
+}