@eggjs/security 4.0.0

package/dist/esm/config/config.default.js

@@ -0,0 +1,351 @@
+import z from 'zod';
+import { Context } from '@eggjs/core';
+const CSRFSupportRequestItem = z.object({
+    path: z.instanceof(RegExp),
+    methods: z.array(z.string()),
+});
+export const LookupAddress = z.object({
+    address: z.string(),
+    family: z.number(),
+});
+const LookupAddressAndStringArray = z.union([z.string(), LookupAddress]).array();
+const SSRFCheckAddressFunction = z.function()
+    .args(z.union([z.string(), LookupAddress, LookupAddressAndStringArray]), z.union([z.number(), z.string()]), z.string())
+    .returns(z.boolean());
+export const SecurityMiddlewareName = z.enum([
+    'csrf',
+    'hsts',
+    'methodnoallow',
+    'noopen',
+    'nosniff',
+    'csp',
+    'xssProtection',
+    'xframe',
+    'dta',
+]);
+/**
+ * (ctx) => boolean
+ */
+const IgnoreOrMatchHandler = z.function().args(z.instanceof(Context)).returns(z.boolean());
+const IgnoreOrMatch = z.union([
+    z.string(), z.instanceof(RegExp), IgnoreOrMatchHandler,
+]);
+const IgnoreOrMatchOption = z.union([IgnoreOrMatch, IgnoreOrMatch.array()]).optional();
+/**
+ * security options
+ * @member Config#security
+ */
+export const SecurityConfig = z.object({
+    /**
+     * domain white list
+     *
+     * Default to `[]`
+     */
+    domainWhiteList: z.array(z.string()).default([]),
+    /**
+     * protocol white list
+     *
+     * Default to `[]`
+     */
+    protocolWhiteList: z.array(z.string()).default([]),
+    /**
+     * default open security middleware
+     *
+     * Default to `'csrf,hsts,methodnoallow,noopen,nosniff,csp,xssProtection,xframe,dta'`
+     */
+    defaultMiddleware: z.union([z.string(), z.array(SecurityMiddlewareName)])
+        .default(SecurityMiddlewareName.options),
+    /**
+     * whether defend csrf attack
+     */
+    csrf: z.preprocess(val => {
+        // transform old config, `csrf: false` to `csrf: { enable: false }`
+        if (typeof val === 'boolean') {
+            return { enable: val };
+        }
+        return val;
+    }, z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+        /**
+         * csrf token detect source type
+         *
+         * Default to `'ctoken'`
+         */
+        type: z.enum(['ctoken', 'referer', 'all', 'any']).default('ctoken'),
+        /**
+         * ignore json request
+         *
+         * Default to `false`
+         *
+         * @deprecated is not safe now, don't use it
+         */
+        ignoreJSON: z.boolean().default(false),
+        /**
+         * csrf token cookie name
+         *
+         * Default to `'csrfToken'`
+         */
+        cookieName: z.union([z.string(), z.array(z.string())]).default('csrfToken'),
+        /**
+         * csrf token session name
+         *
+         * Default to `'csrfToken'`
+         */
+        sessionName: z.string().default('csrfToken'),
+        /**
+         * csrf token request header name
+         *
+         * Default to `'x-csrf-token'`
+         */
+        headerName: z.string().default('x-csrf-token'),
+        /**
+         * csrf token request body field name
+         *
+         * Default to `'_csrf'`
+         */
+        bodyName: z.union([z.string(), z.array(z.string())]).default('_csrf'),
+        /**
+         * csrf token request query field name
+         *
+         * Default to `'_csrf'`
+         */
+        queryName: z.union([z.string(), z.array(z.string())]).default('_csrf'),
+        /**
+         * rotate csrf token when it is invalid
+         *
+         * Default to `false`
+         */
+        rotateWhenInvalid: z.boolean().default(false),
+        /**
+         * These config works when using `'ctoken'` type
+         *
+         * Default to `false`
+         */
+        useSession: z.boolean().default(false),
+        /**
+         * csrf token cookie domain setting,
+         * can be `(ctx) => string` or `string`
+         *
+         * Default to `undefined`, auto set the cookie domain in the safe way
+         */
+        cookieDomain: z.union([
+            z.string(),
+            z.function()
+                .args(z.instanceof(Context))
+                .returns(z.string()),
+        ]).optional(),
+        /**
+         * csrf token check requests config
+         */
+        supportedRequests: z.array(CSRFSupportRequestItem)
+            .default([
+            { path: /^\//, methods: ['POST', 'PATCH', 'DELETE', 'PUT', 'CONNECT'] },
+        ]),
+        /**
+         * referer or origin header white list.
+         * It only works when using `'referer'` type
+         *
+         * Default to `[]`
+         */
+        refererWhiteList: z.array(z.string()).default([]),
+        /**
+         * csrf token cookie options
+         *
+         * Default to `{
+         *   signed: false,
+         *   httpOnly: false,
+         *   overwrite: true,
+         * }`
+         */
+        cookieOptions: z.object({
+            signed: z.boolean(),
+            httpOnly: z.boolean(),
+            overwrite: z.boolean(),
+        }).default({
+            signed: false,
+            httpOnly: false,
+            overwrite: true,
+        }),
+    }).default({})),
+    /**
+     * whether enable X-Frame-Options response header
+     */
+    xframe: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+        /**
+         * X-Frame-Options value, can be `'DENY'`, `'SAMEORIGIN'`, `'ALLOW-FROM https://example.com'`
+         *
+         * Default to `'SAMEORIGIN'`
+         */
+        value: z.string().default('SAMEORIGIN'),
+    }).default({}),
+    /**
+     * whether enable Strict-Transport-Security response header
+     */
+    hsts: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `false`
+         */
+        enable: z.boolean().default(false),
+        /**
+         * Max age of Strict-Transport-Security in seconds
+         *
+         * Default to `365 * 24 * 3600`
+         */
+        maxAge: z.number().default(365 * 24 * 3600),
+        /**
+         * Whether include sub domains
+         *
+         * Default to `false`
+         */
+        includeSubdomains: z.boolean().default(false),
+    }).default({}),
+    /**
+     * whether enable Http Method filter
+     */
+    methodnoallow: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+    }).default({}),
+    /**
+     * whether enable IE automatically download open
+     */
+    noopen: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+    }).default({}),
+    /**
+     * whether enable IE8 automatically detect mime
+     */
+    nosniff: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+    }).default({}),
+    /**
+     * whether enable IE8 XSS Filter
+     */
+    xssProtection: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+        /**
+         * X-XSS-Protection response header value
+         *
+         * Default to `'1; mode=block'`
+         */
+        value: z.coerce.string().default('1; mode=block'),
+    }).default({}),
+    /**
+     * content security policy config
+     */
+    csp: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `false`
+         */
+        enable: z.boolean().default(false),
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP#csp_overview
+        policy: z.record(z.union([z.string(), z.array(z.string()), z.boolean()])).default({}),
+        /**
+         * whether enable report only mode
+         * Default to `undefined`
+         */
+        reportOnly: z.boolean().optional(),
+        /**
+         * whether support IE
+         * Default to `undefined`
+         */
+        supportIE: z.boolean().optional(),
+    }).default({}),
+    /**
+     * whether enable referrer policy
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
+     */
+    referrerPolicy: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `false`
+         */
+        enable: z.boolean().default(false),
+        /**
+         * referrer policy value
+         *
+         * Default to `'no-referrer-when-downgrade'`
+         */
+        value: z.string().default('no-referrer-when-downgrade'),
+    }).default({}),
+    /**
+     * whether enable auto avoid directory traversal attack
+     */
+    dta: z.object({
+        match: IgnoreOrMatchOption,
+        ignore: IgnoreOrMatchOption,
+        /**
+         * Default to `true`
+         */
+        enable: z.boolean().default(true),
+    }).default({}),
+    ssrf: z.object({
+        ipBlackList: z.array(z.string()).optional(),
+        ipExceptionList: z.array(z.string()).optional(),
+        hostnameExceptionList: z.array(z.string()).optional(),
+        checkAddress: SSRFCheckAddressFunction.optional(),
+    }).default({}),
+    match: z.union([IgnoreOrMatch, IgnoreOrMatch.array()]).optional(),
+    ignore: z.union([IgnoreOrMatch, IgnoreOrMatch.array()]).optional(),
+    __protocolWhiteListSet: z.set(z.string()).optional().readonly(),
+});
+const SecurityHelperOnTagAttrHandler = z.function()
+    .args(z.string(), z.string(), z.string(), z.boolean())
+    .returns(z.union([z.string(), z.void()]));
+export const SecurityHelperConfig = z.object({
+    shtml: z.object({
+        /**
+         * tag attribute white list
+         */
+        whiteList: z.record(z.array(z.string())).optional(),
+        /**
+         * domain white list
+         * @deprecated use `config.security.domainWhiteList` instead
+         */
+        domainWhiteList: z.array(z.string()).optional(),
+        /**
+         * tag attribute handler
+         */
+        onTagAttr: SecurityHelperOnTagAttrHandler.optional(),
+    }).default({}),
+});
+export default {
+    security: SecurityConfig.parse({}),
+    helper: SecurityHelperConfig.parse({}),
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.default.js","sourceRoot":"","sources":["../../../src/config/config.default.ts"],"names":[],"mappings":"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"}

package/dist/esm/config/config.local.d.ts

@@ -0,0 +1,5 @@
+import { SecurityConfig } from '../types.js';
+declare const _default: {
+    security: SecurityConfig;
+};
+export default _default;

package/dist/esm/config/config.local.js

@@ -0,0 +1,8 @@
+export default {
+    security: {
+        hsts: {
+            enable: false,
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmxvY2FsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbmZpZy9jb25maWcubG9jYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsZUFBZTtJQUNiLFFBQVEsRUFBRTtRQUNSLElBQUksRUFBRTtZQUNKLE1BQU0sRUFBRSxLQUFLO1NBQ2Q7S0FDZ0I7Q0FDcEIsQ0FBQyJ9

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+import './types.js';

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import './types.js';
+// module.exports = require('./app/middleware/securities');
+// module.exports.csp = require('./lib/middlewares/csp');
+// module.exports.csrf = require('./lib/middlewares/csrf');
+// module.exports.methodNoAllow = require('./lib/middlewares/methodnoallow');
+// module.exports.noopen = require('./lib/middlewares/noopen');
+// module.exports.nosniff = require('./lib/middlewares/nosniff');
+// module.exports.xssProtection = require('./lib/middlewares/xssProtection');
+// module.exports.xframe = require('./lib/middlewares/xframe');
+// module.exports.safeRedirect = require('./lib/safe_redirect');
+// module.exports.utils = require('./lib/utils');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxZQUFZLENBQUM7QUFFcEIsMkRBQTJEO0FBQzNELHlEQUF5RDtBQUN6RCwyREFBMkQ7QUFDM0QsNkVBQTZFO0FBQzdFLCtEQUErRDtBQUMvRCxpRUFBaUU7QUFDakUsNkVBQTZFO0FBQzdFLCtEQUErRDtBQUMvRCxnRUFBZ0U7QUFDaEUsaURBQWlEIn0=

package/dist/esm/lib/extend/safe_curl.d.ts

@@ -0,0 +1,16 @@
+import { EggCore } from '@eggjs/core';
+import type { SSRFCheckAddressFunction } from '../../types.js';
+type HttpClient = EggCore['HttpClient'];
+type HttpClientParameters = Parameters<HttpClient['prototype']['request']>;
+export type HttpClientRequestURL = HttpClientParameters[0];
+export type HttpClientOptions = HttpClientParameters[1] & {
+    checkAddress?: SSRFCheckAddressFunction;
+};
+export type HttpClientResponse<T = any> = Awaited<ReturnType<HttpClient['prototype']['request']>> & {
+    data: T;
+};
+/**
+ * safe curl with ssrf protection
+ */
+export declare function safeCurlForApplication<T = any>(app: EggCore, url: HttpClientRequestURL, options?: HttpClientOptions): Promise<import("urllib").HttpClientResponse<T>>;
+export {};

package/dist/esm/lib/extend/safe_curl.js

@@ -0,0 +1,25 @@
+const SSRF_HTTPCLIENT = Symbol('SSRF_HTTPCLIENT');
+/**
+ * safe curl with ssrf protection
+ */
+export async function safeCurlForApplication(app, url, options = {}) {
+    const ssrfConfig = app.config.security.ssrf;
+    if (ssrfConfig?.checkAddress) {
+        options.checkAddress = ssrfConfig.checkAddress;
+    }
+    else {
+        app.logger.warn('[@eggjs/security] please configure `config.security.ssrf` first');
+    }
+    if (ssrfConfig?.checkAddress) {
+        let httpClient = app[SSRF_HTTPCLIENT];
+        // use the new httpClient init with checkAddress
+        if (!httpClient) {
+            httpClient = app[SSRF_HTTPCLIENT] = app.createHttpClient({
+                checkAddress: ssrfConfig.checkAddress,
+            });
+        }
+        return await httpClient.request(url, options);
+    }
+    return await app.curl(url, options);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZV9jdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9leHRlbmQvc2FmZV9jdXJsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBUWxEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxzQkFBc0IsQ0FBVSxHQUFZLEVBQUUsR0FBeUIsRUFBRSxVQUE2QixFQUFFO0lBQzVILE1BQU0sVUFBVSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQztJQUM1QyxJQUFJLFVBQVUsRUFBRSxZQUFZLEVBQUUsQ0FBQztRQUM3QixPQUFPLENBQUMsWUFBWSxHQUFHLFVBQVUsQ0FBQyxZQUFZLENBQUM7SUFDakQsQ0FBQztTQUFNLENBQUM7UUFDTixHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxpRUFBaUUsQ0FBQyxDQUFDO0lBQ3JGLENBQUM7SUFFRCxJQUFJLFVBQVUsRUFBRSxZQUFZLEVBQUUsQ0FBQztRQUM3QixJQUFJLFVBQVUsR0FBRyxHQUFHLENBQUMsZUFBZSxDQUE0QyxDQUFDO1FBQ2pGLGdEQUFnRDtRQUNoRCxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDaEIsVUFBVSxHQUFHLEdBQUcsQ0FBQyxlQUFlLENBQUMsR0FBRyxHQUFHLENBQUMsZ0JBQWdCLENBQUM7Z0JBQ3ZELFlBQVksRUFBRSxVQUFVLENBQUMsWUFBWTthQUN0QyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0QsT0FBTyxNQUFNLFVBQVUsQ0FBQyxPQUFPLENBQUksR0FBRyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFRCxPQUFPLE1BQU0sR0FBRyxDQUFDLElBQUksQ0FBSSxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDekMsQ0FBQyJ9

package/dist/esm/lib/helper/cliFilter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * remote command execution
+ */
+export default function cliFilter(text: string): string;

package/dist/esm/lib/helper/cliFilter.js

@@ -0,0 +1,17 @@
+/**
+ * remote command execution
+ */
+const BASIC_ALPHABETS = new Set('abcdefghijklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ.-_'.split(''));
+export default function cliFilter(text) {
+    const str = '' + text;
+    let res = '';
+    let ascii;
+    for (let index = 0; index < str.length; index++) {
+        ascii = str[index];
+        if (BASIC_ALPHABETS.has(ascii)) {
+            res += ascii;
+        }
+    }
+    return res;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpRmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9oZWxwZXIvY2xpRmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsTUFBTSxlQUFlLEdBQUcsSUFBSSxHQUFHLENBQUMsbUVBQW1FLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFFL0csTUFBTSxDQUFDLE9BQU8sVUFBVSxTQUFTLENBQUMsSUFBWTtJQUM1QyxNQUFNLEdBQUcsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDO0lBQ3RCLElBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQztJQUNiLElBQUksS0FBSyxDQUFDO0lBRVYsS0FBSyxJQUFJLEtBQUssR0FBRyxDQUFDLEVBQUUsS0FBSyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQztRQUNoRCxLQUFLLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ25CLElBQUksZUFBZSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQy9CLEdBQUcsSUFBSSxLQUFLLENBQUM7UUFDZixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyJ9

package/dist/esm/lib/helper/escape.d.ts

@@ -0,0 +1,2 @@
+import escapeHTML from 'escape-html';
+export default escapeHTML;

package/dist/esm/lib/helper/escape.js

@@ -0,0 +1,3 @@
+import escapeHTML from 'escape-html';
+export default escapeHTML;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9oZWxwZXIvZXNjYXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sVUFBVSxNQUFNLGFBQWEsQ0FBQztBQUVyQyxlQUFlLFVBQVUsQ0FBQyJ9

package/dist/esm/lib/helper/escapeShellArg.d.ts

@@ -0,0 +1 @@
+export default function escapeShellArg(text: string): string;

package/dist/esm/lib/helper/escapeShellArg.js

@@ -0,0 +1,5 @@
+export default function escapeShellArg(text) {
+    const str = '' + text;
+    return '\'' + str.replace(/\\/g, '\\\\').replace(/\'/g, '\\\'') + '\'';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlU2hlbGxBcmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2hlbHBlci9lc2NhcGVTaGVsbEFyZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsT0FBTyxVQUFVLGNBQWMsQ0FBQyxJQUFZO0lBQ2pELE1BQU0sR0FBRyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDdEIsT0FBTyxJQUFJLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUM7QUFDekUsQ0FBQyJ9

package/dist/esm/lib/helper/escapeShellCmd.d.ts

@@ -0,0 +1 @@
+export default function escapeShellCmd(text: string): string;

package/dist/esm/lib/helper/escapeShellCmd.js

@@ -0,0 +1,14 @@
+const BASIC_ALPHABETS = new Set('#&;`|*?~<>^()[]{}$;\'",\x0A\xFF'.split(''));
+export default function escapeShellCmd(text) {
+    const str = '' + text;
+    let res = '';
+    let ascii;
+    for (let index = 0; index < str.length; index++) {
+        ascii = str[index];
+        if (!BASIC_ALPHABETS.has(ascii)) {
+            res += ascii;
+        }
+    }
+    return res;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlU2hlbGxDbWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2hlbHBlci9lc2NhcGVTaGVsbENtZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLGVBQWUsR0FBRyxJQUFJLEdBQUcsQ0FBQyxpQ0FBaUMsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUU3RSxNQUFNLENBQUMsT0FBTyxVQUFVLGNBQWMsQ0FBQyxJQUFZO0lBQ2pELE1BQU0sR0FBRyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDdEIsSUFBSSxHQUFHLEdBQUcsRUFBRSxDQUFDO0lBQ2IsSUFBSSxLQUFLLENBQUM7SUFFVixLQUFLLElBQUksS0FBSyxHQUFHLENBQUMsRUFBRSxLQUFLLEdBQUcsR0FBRyxDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQ2hELEtBQUssR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbkIsSUFBSSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUNoQyxHQUFHLElBQUksS0FBSyxDQUFDO1FBQ2YsQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUMifQ==

package/dist/esm/lib/helper/index.d.ts

@@ -0,0 +1,21 @@
+import cliFilter from './cliFilter.js';
+import escape from './escape.js';
+import escapeShellArg from './escapeShellArg.js';
+import escapeShellCmd from './escapeShellCmd.js';
+import shtml from './shtml.js';
+import sjs from './sjs.js';
+import sjson from './sjson.js';
+import spath from './spath.js';
+import surl from './surl.js';
+declare const _default: {
+    cliFilter: typeof cliFilter;
+    escape: typeof escape;
+    escapeShellArg: typeof escapeShellArg;
+    escapeShellCmd: typeof escapeShellCmd;
+    shtml: typeof shtml;
+    sjs: typeof sjs;
+    sjson: typeof sjson;
+    spath: typeof spath;
+    surl: typeof surl;
+};
+export default _default;

package/dist/esm/lib/helper/index.js

@@ -0,0 +1,21 @@
+import cliFilter from './cliFilter.js';
+import escape from './escape.js';
+import escapeShellArg from './escapeShellArg.js';
+import escapeShellCmd from './escapeShellCmd.js';
+import shtml from './shtml.js';
+import sjs from './sjs.js';
+import sjson from './sjson.js';
+import spath from './spath.js';
+import surl from './surl.js';
+export default {
+    cliFilter,
+    escape,
+    escapeShellArg,
+    escapeShellCmd,
+    shtml,
+    sjs,
+    sjson,
+    spath,
+    surl,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2hlbHBlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxnQkFBZ0IsQ0FBQztBQUN2QyxPQUFPLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDakMsT0FBTyxjQUFjLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxjQUFjLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBQy9CLE9BQU8sR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUMzQixPQUFPLEtBQUssTUFBTSxZQUFZLENBQUM7QUFDL0IsT0FBTyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBQy9CLE9BQU8sSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUU3QixlQUFlO0lBQ2IsU0FBUztJQUNULE1BQU07SUFDTixjQUFjO0lBQ2QsY0FBYztJQUNkLEtBQUs7SUFDTCxHQUFHO0lBQ0gsS0FBSztJQUNMLEtBQUs7SUFDTCxJQUFJO0NBQ0wsQ0FBQyJ9

package/dist/esm/lib/helper/shtml.d.ts

@@ -0,0 +1,2 @@
+import type { BaseContextClass } from '@eggjs/core';
+export default function shtml(this: BaseContextClass, val: string): string;

package/dist/esm/lib/helper/shtml.js

@@ -0,0 +1,70 @@
+import xss from 'xss';
+import { isSafeDomain, getFromUrl } from '../utils.js';
+const BUILD_IN_ON_TAG_ATTR = Symbol('buildInOnTagAttr');
+// default rule: https://github.com/leizongmin/js-xss/blob/master/lib/default.js
+// add domain filter based on xss module
+// custom options http://jsxss.com/zh/options.html
+// eg: support a tag，filter attributes except for title : whiteList: {a: ['title']}
+export default function shtml(val) {
+    if (typeof val !== 'string') {
+        return val;
+    }
+    const securityOptions = this.ctx.securityOptions;
+    let buildInOnTagAttrHandler;
+    const shtmlConfig = {
+        ...this.app.config.helper.shtml,
+        ...securityOptions.shtml,
+        [BUILD_IN_ON_TAG_ATTR]: buildInOnTagAttrHandler,
+    };
+    const domainWhiteList = this.app.config.security.domainWhiteList;
+    const app = this.app;
+    // filter href and src attribute if not in domain white list
+    if (!shtmlConfig[BUILD_IN_ON_TAG_ATTR]) {
+        shtmlConfig[BUILD_IN_ON_TAG_ATTR] = (_tag, name, value, isWhiteAttr) => {
+            if (isWhiteAttr && (name === 'href' || name === 'src')) {
+                if (!value) {
+                    return;
+                }
+                value = String(value);
+                if (value[0] === '/' || value[0] === '#') {
+                    return;
+                }
+                const hostname = getFromUrl(value, 'hostname');
+                if (!hostname) {
+                    return;
+                }
+                // If we don't have our hostname in the app.security.domainWhiteList,
+                // Just check for `shtmlConfig.domainWhiteList` and `ctx.whiteList`.
+                if (!isSafeDomain(hostname, domainWhiteList)) {
+                    // Check for `shtmlConfig.domainWhiteList` first (duplicated now)
+                    if (shtmlConfig.domainWhiteList && shtmlConfig.domainWhiteList.length > 0) {
+                        app.deprecate('[@eggjs/security/lib/helper/shtml] `config.helper.shtml.domainWhiteList` has been deprecate. Please use `config.security.domainWhiteList` instead.');
+                        if (!isSafeDomain(hostname, shtmlConfig.domainWhiteList)) {
+                            return '';
+                        }
+                    }
+                    else {
+                        return '';
+                    }
+                }
+            }
+        };
+        // avoid overriding user configuration 'onTagAttr'
+        if (shtmlConfig.onTagAttr) {
+            const customOnTagAttrHandler = shtmlConfig.onTagAttr;
+            shtmlConfig.onTagAttr = function (tag, name, value, isWhiteAttr) {
+                const result = customOnTagAttrHandler.apply(this, [tag, name, value, isWhiteAttr]);
+                if (result !== undefined) {
+                    return result;
+                }
+                // fallback to build-in handler
+                return shtmlConfig[BUILD_IN_ON_TAG_ATTR].apply(this, [tag, name, value, isWhiteAttr]);
+            };
+        }
+        else {
+            shtmlConfig.onTagAttr = shtmlConfig[BUILD_IN_ON_TAG_ATTR];
+        }
+    }
+    return xss(val, shtmlConfig);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/helper/sjs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Escape JavaScript to \xHH format
+ */
+export default function escapeJavaScript(text: string): string;