pentest-tool-lite 3.9.2 → 3.10.6

package/{src → dist/src}/logger/Console.js

@@ -8,42 +8,42 @@ class Console {
     constructor() {
         this.levels = ['ALL', 'DEBUG', 'VERBOSE', 'INFO', 'WARNING', 'ERROR', 'NONE'];
     }
-    debug(message) {
+    debug(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 1) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    verbose(message) {
+    verbose(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 2) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    info(message) {
+    info(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 3) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    warning(message) {
+    warning(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 4) {
             return;
         }
-        console.warn(message);
+        console.warn(message, ...args);
     }
-    error(message) {
+    error(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 5) {
             return;
         }
-        console.error(message);
+        console.error(message, ...args);
     }
     /**
      * What a terrible failure
      * @param message
      */
-    wtf(message) {
-        console.error(message);
+    wtf(message, ...args) {
+        console.error(message, ...args);
     }
 }
 exports.default = Console;

package/dist/src/metadata/HTML.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+declare class HTML extends Test {
+    name: string;
+    test({ url }: TestParameters): Promise<Result>;
+}
+export default HTML;

package/dist/src/metadata/HTML.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+class HTML extends Test_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'HTML';
+    }
+    test(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url }) {
+            logger_1.default.info(`Starting ${this.constructor.name} test...`);
+            const response = yield request_1.default.get(url);
+            const html = response.body;
+            return {
+                status: 'SUCCESS',
+                title: this.constructor.name,
+                description: '',
+                metadata: {
+                    html,
+                },
+                results: [],
+            };
+        });
+    }
+}
+exports.default = HTML;

package/dist/src/metadata/Markdown.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+declare class Markdown extends Test {
+    name: string;
+    test({ url }: TestParameters): Promise<Result>;
+}
+export default Markdown;

package/dist/src/metadata/Markdown.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_html_markdown_1 = require("node-html-markdown");
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+class Markdown extends Test_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'Markdown';
+    }
+    test(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url }) {
+            logger_1.default.info(`Starting ${this.constructor.name} test...`);
+            const response = yield request_1.default.get(url);
+            const html = response.body;
+            const markdown = node_html_markdown_1.NodeHtmlMarkdown.translate(html);
+            return {
+                status: 'SUCCESS',
+                title: this.constructor.name,
+                description: '',
+                metadata: {
+                    markdown,
+                },
+                results: [],
+            };
+        });
+    }
+}
+exports.default = Markdown;

package/dist/src/metadata/ResponseTime.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+declare class ResponseTime extends Test {
+    name: string;
+    test({ url }: TestParameters): Promise<Result>;
+}
+export default ResponseTime;

package/dist/src/metadata/ResponseTime.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+class ResponseTime extends Test_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'ResponseTime';
+    }
+    test(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url }) {
+            logger_1.default.info(`Starting ${this.constructor.name} test...`);
+            const response = yield request_1.default.get(url);
+            return {
+                status: 'SUCCESS',
+                title: this.constructor.name,
+                description: '',
+                metadata: {
+                    duration: response.duration,
+                },
+                results: [],
+            };
+        });
+    }
+}
+exports.default = ResponseTime;

package/dist/src/metadata/index.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+export default class Metadata extends Test {
+    name: string;
+    constructor();
+    test(params: TestParameters): Promise<Result>;
+}

package/dist/src/metadata/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const HTML_1 = __importDefault(require("./HTML"));
+const Markdown_1 = __importDefault(require("./Markdown"));
+const ResponseTime_1 = __importDefault(require("./ResponseTime"));
+class Metadata extends Test_1.default {
+    constructor() {
+        super();
+        this.name = 'Metadata';
+        this.tests = [
+            new HTML_1.default(),
+            new Markdown_1.default(),
+            new ResponseTime_1.default(),
+        ];
+    }
+    test(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tests = this.getTests();
+            const results = [];
+            for (const test of tests) {
+                let result = null;
+                try {
+                    result = yield test.run(params);
+                }
+                catch (_a) {
+                    result = {
+                        status: 'ERROR',
+                        title: test.name,
+                        description: 'Test failed or cannot be run!',
+                    };
+                }
+                results.push(result);
+            }
+            return {
+                status: this.getStatus(results.map(result => result.status)),
+                title: this.name,
+                description: '',
+                results,
+            };
+        });
+    }
+}
+exports.default = Metadata;

package/{src → dist/src}/request/NodeFetch.d.ts

@@ -1,4 +1,6 @@
 import Request, { Options, Response } from './Request';
 export default class NodeFetch implements Request {
+    protected cache: PentestCache;
+    constructor(cache: PentestCache);
     get(url: string, options?: Options): Promise<Response>;
 }

package/{src → dist/src}/request/NodeFetch.js

@@ -12,29 +12,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_fetch_1 = __importDefault(require("node-fetch"));
 const config_1 = __importDefault(require("../config"));
 const getHeaders = (headers) => {
     const keyValues = {};
-    Object.keys(headers).forEach((header) => {
-        if (headers[header].length === 1 && header !== 'set-cookie') {
-            keyValues[header] = headers[header][0];
+    headers.forEach((value, header) => {
+        if (value.length === 1 && header !== 'set-cookie') {
+            keyValues[header] = value[0];
         }
         else {
-            keyValues[header] = headers[header];
+            keyValues[header] = value;
         }
     });
     return keyValues;
 };
 class NodeFetch {
+    constructor(cache) {
+        this.cache = cache;
+    }
     get(url, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.cache.has(url)) {
+                return this.cache.get(url);
+            }
             const defaultOptions = config_1.default.request.options;
-            const response = yield (0, node_fetch_1.default)(url, Object.assign(Object.assign({}, defaultOptions), options));
+            const startTime = Date.now();
+            const response = yield fetch(url, Object.assign(Object.assign({}, defaultOptions), options));
+            const endTime = Date.now();
             const body = yield response.text();
             const statusCode = response.status;
             const statusText = response.statusText;
-            const headers = getHeaders(response.headers.raw());
+            const headers = getHeaders(response.headers);
+            this.cache.add(url, {
+                response,
+                statusCode,
+                statusText,
+                headers,
+                body,
+                url,
+                finalUrl: response.url,
+                duration: (endTime - startTime) / 1000,
+            });
             return {
                 response,
                 statusCode,
@@ -42,6 +59,8 @@ class NodeFetch {
                 headers,
                 body,
                 url,
+                finalUrl: response.url,
+                duration: (endTime - startTime) / 1000,
             };
         });
     }

package/{src → dist/src}/request/Request.d.ts

@@ -5,11 +5,13 @@ export type Options = {
 };
 export type Response = {
     url: string;
+    finalUrl: string;
     body: string;
     statusCode: number;
     statusText: string;
     headers: any;
     response: any;
+    duration: number;
 };
 export default interface Request {
     get(url: string, options?: Options): Promise<Response>;

package/dist/src/request/cache/BlackHoleCache.d.ts

@@ -0,0 +1,7 @@
+declare class BlackHoleCache implements PentestCache {
+    add(): void;
+    has(): boolean;
+    get(): any;
+    clear(): void;
+}
+export default BlackHoleCache;

package/{src → dist/src}/request/cache/BlackHoleCache.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class BlackHoleCache {
-    add(url, response) {
+    add() {
         return;
     }
-    has(url) {
+    has() {
         return false;
     }
-    get(url) {
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    get() {
         return null;
     }
     clear() {

package/{src → dist/src}/request/cache/UnlimitedCache.d.ts

@@ -1,5 +1,4 @@
-import Cache from './Cache';
-export default class UnlimitedCache implements Cache {
+export default class UnlimitedCache implements PentestCache {
     protected requests: Record<string, any>;
     constructor();
     add(url: string, response: any): void;

package/{src → dist/src}/request/cache/UnlimitedCache.js

@@ -4,12 +4,14 @@ class UnlimitedCache {
     constructor() {
         this.requests = {};
     }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     add(url, response) {
         this.requests[url] = response;
     }
     has(url) {
         return Object.prototype.hasOwnProperty.call(this.requests, url);
     }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     get(url) {
         if (!this.has(url)) {
             return null;

package/dist/src/request/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NodeFetch_1 = __importDefault(require("./NodeFetch"));
+const UnlimitedCache_1 = __importDefault(require("./cache/UnlimitedCache"));
+const BlackHoleCache_1 = __importDefault(require("./cache/BlackHoleCache"));
+const config_1 = __importDefault(require("../config"));
+const cache = config_1.default.request.cache.type === 'UNLIMITED' ? new UnlimitedCache_1.default() : new BlackHoleCache_1.default();
+exports.default = new NodeFetch_1.default(cache);

package/{src → dist/src}/security/HTTPS.js

@@ -38,11 +38,18 @@ class HTTPS extends Test_1.default {
         return __awaiter(this, arguments, void 0, function* ({ url }) {
             logger_1.default.info('Starting HTTPS test...');
             const unsecureUrl = this.toHttp(url);
+            logger_1.default.debug('Unsecure URL', unsecureUrl);
             const response = yield request_1.default.get(unsecureUrl, { redirect: 'manual' });
+            logger_1.default.debug('Response', { statusCode: response.statusCode, headers: response.headers });
             if (!this.isRedirect(response)) {
                 return {
                     status: 'ERROR',
                     title: 'HTTPS',
+                    metadata: {
+                        statusCode: response.statusCode,
+                        unsecureUrl,
+                        finalUrl: response.finalUrl,
+                    },
                     description: `Request to not secure url returned ${response.statusCode}!`,
                 };
             }
@@ -50,19 +57,31 @@ class HTTPS extends Test_1.default {
                 return {
                     status: 'ERROR',
                     title: 'HTTPS',
+                    metadata: {
+                        statusCode: response.statusCode,
+                        unsecureUrl,
+                        finalUrl: response.finalUrl,
+                    },
                     description: `Request to not secure url returned non-secure redirect url ${response.headers.location}!`,
                 };
             }
             return {
                 status: 'SUCCESS',
                 title: 'HTTPS',
+                metadata: {
+                    statusCode: response.statusCode,
+                    unsecureUrl,
+                    finalUrl: response.finalUrl,
+                },
                 description: `Request to not secure url responded with status code ${response.statusCode} and redirect url ${response.headers.location}.`,
             };
         });
     }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     isRedirect(response) {
         return Math.floor(response.statusCode / 100) === 3 && 'location' in response.headers;
     }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     isRedirectSecure(response) {
         return response.headers.location.startsWith('https');
     }

package/dist/src/security/Redirect.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+declare class Redirect extends Test {
+    name: string;
+    test({ url }: TestParameters): Promise<Result>;
+}
+export default Redirect;

package/dist/src/security/Redirect.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+class Redirect extends Test_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'Redirect';
+    }
+    test(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ url }) {
+            logger_1.default.info('Starting Redirect test...');
+            const response = yield request_1.default.get(url, { redirect: 'follow' });
+            if (response.response.redirected) {
+                const originalUrl = new URL(url);
+                const finalUrl = new URL(response.response.url);
+                if (originalUrl.hostname !== finalUrl.hostname) {
+                    return {
+                        status: 'ERROR',
+                        title: this.name,
+                        description: 'URL redirects to different hostname!',
+                    };
+                }
+                return {
+                    status: 'SUCCESS',
+                    title: this.name,
+                    description: 'Request was redirected but to the same hostname.',
+                };
+            }
+            return {
+                status: 'SUCCESS',
+                title: this.name,
+                description: 'Request was not redirected.',
+            };
+        });
+    }
+}
+exports.default = Redirect;

package/{src → dist/src}/security/__TESTS__/ContentSecurityPolicy.test.js

@@ -16,6 +16,7 @@ const ContentSecurityPolicy_1 = __importDefault(require("../ContentSecurityPolic
 const request_1 = __importDefault(require("../../request"));
 test('Content-Security-Policy test with correct header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new ContentSecurityPolicy_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -31,6 +32,7 @@ test('Content-Security-Policy test with correct header', () => __awaiter(void 0,
 }));
 test('Content-Security-Policy test with missing Content-Security-Policy header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new ContentSecurityPolicy_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({

package/{src → dist/src}/security/__TESTS__/FingerPrint.test.js

@@ -16,6 +16,7 @@ const FingerPrint_1 = __importDefault(require("../FingerPrint"));
 const request_1 = __importDefault(require("../../request"));
 test('FingerPrint test without any finger print header present', () => __awaiter(void 0, void 0, void 0, function* () {
     const fingerPrint = new FingerPrint_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -31,6 +32,7 @@ test('FingerPrint test without any finger print header present', () => __awaiter
 }));
 test('FingerPrint test with finger print header present', () => __awaiter(void 0, void 0, void 0, function* () {
     const fingerPrint = new FingerPrint_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({

package/{src → dist/src}/security/__TESTS__/HSTS.test.js

@@ -16,6 +16,7 @@ const HSTS_1 = __importDefault(require("../HSTS"));
 const request_1 = __importDefault(require("../../request"));
 test('HSTS test with correct header', () => __awaiter(void 0, void 0, void 0, function* () {
     const hsts = new HSTS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -31,6 +32,7 @@ test('HSTS test with correct header', () => __awaiter(void 0, void 0, void 0, fu
 }));
 test('HSTS test with low max age value', () => __awaiter(void 0, void 0, void 0, function* () {
     const hsts = new HSTS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -46,6 +48,7 @@ test('HSTS test with low max age value', () => __awaiter(void 0, void 0, void 0,
 }));
 test('HSTS test with missing HSTS header', () => __awaiter(void 0, void 0, void 0, function* () {
     const hsts = new HSTS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({

package/{src → dist/src}/security/__TESTS__/HTTPS.test.js

@@ -16,6 +16,7 @@ const HTTPS_1 = __importDefault(require("../HTTPS"));
 const request_1 = __importDefault(require("../../request"));
 test('HTTPS test with correct statusCode and location header', () => __awaiter(void 0, void 0, void 0, function* () {
     const https = new HTTPS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -32,6 +33,7 @@ test('HTTPS test with correct statusCode and location header', () => __awaiter(v
 }));
 test('HTTPS test with wrong statusCode', () => __awaiter(void 0, void 0, void 0, function* () {
     const https = new HTTPS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -46,6 +48,7 @@ test('HTTPS test with wrong statusCode', () => __awaiter(void 0, void 0, void 0,
 }));
 test('HTTPS test with correct statusCode but wrong redirect location', () => __awaiter(void 0, void 0, void 0, function* () {
     const https = new HTTPS_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({

package/{src → dist/src}/security/__TESTS__/XFrameOptions.test.js

@@ -16,6 +16,7 @@ const XFrameOptions_1 = __importDefault(require("../XFrameOptions"));
 const request_1 = __importDefault(require("../../request"));
 test('X-Frame-Options test with correct header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new XFrameOptions_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -31,6 +32,7 @@ test('X-Frame-Options test with correct header', () => __awaiter(void 0, void 0,
 }));
 test('X-Frame-Options test with missing X-Frame-Options header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new XFrameOptions_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({

package/{src → dist/src}/security/__TESTS__/XXSSProtection.test.js

@@ -16,6 +16,7 @@ const XXSSProtection_1 = __importDefault(require("../XXSSProtection"));
 const request_1 = __importDefault(require("../../request"));
 test('X-XSS-Protection test with correct header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new XXSSProtection_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({
@@ -31,6 +32,7 @@ test('X-XSS-Protection test with correct header', () => __awaiter(void 0, void 0
 }));
 test('X-XSS-Protection test with missing X-XSS-Protection header', () => __awaiter(void 0, void 0, void 0, function* () {
     const pentest = new XXSSProtection_1.default();
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
     const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             resolve({