pentest-tool-lite 3.9.3 → 3.10.8

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 juffalow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/{src → dist}/Pentest.d.ts

@@ -5,6 +5,7 @@ interface PentestResult {
     html: Result;
     seo: Result;
     wordpress: Result;
+    metadata: Result;
 }
 declare class Pentest {
     run(url: string): Promise<PentestResult>;

package/dist/Pentest.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const security_1 = __importDefault(require("./security"));
+const dns_1 = __importDefault(require("./dns"));
+const html_1 = __importDefault(require("./html"));
+const seo_1 = __importDefault(require("./seo"));
+const wordpress_1 = __importDefault(require("./wordpress"));
+const metadata_1 = __importDefault(require("./metadata"));
+class Pentest {
+    async run(url) {
+        const general = new dns_1.default();
+        const security = new security_1.default();
+        const html = new html_1.default();
+        const seo = new seo_1.default();
+        const wordPress = new wordpress_1.default();
+        const metadata = new metadata_1.default();
+        const [generalResult, securityResult, htmlResult, seoResult, wordPressResult, metadataResult] = await Promise.all([
+            general.run({ url }),
+            security.run({ url }),
+            html.run({ url }),
+            seo.run({ url }),
+            wordPress.run({ url }),
+            metadata.run({ url }),
+        ]);
+        // const [ generalResult, securityResult, htmlResult, seoResult, wordPressResult ] = result.map(promise => promise.status === 'fulfilled' ? promise.value : {});
+        // const [ generalResult, securityResult, htmlResult, seoResult, wordPressResult ] = result;
+        // const generalResult = <Result> await general.run({ url });
+        // const securityResult = <Result> await security.run({ url });
+        // const htmlResult = <Result> await html.run({ url });
+        // const seoResult = <Result> await seo.run({ url });
+        // const wordPressResult = <Result> await wordPress.run({ url });
+        // console.log(metadataResult);
+        return {
+            security: securityResult,
+            dns: generalResult,
+            html: htmlResult,
+            seo: seoResult,
+            wordpress: wordPressResult,
+            metadata: metadataResult,
+        };
+    }
+}
+exports.default = Pentest;

package/{src → dist}/Test.d.ts

@@ -6,6 +6,7 @@ export type Result = {
     status: Status;
     title: string;
     description: string;
+    metadata?: Record<string, string | number | boolean>;
     results?: Array<Result>;
 };
 export default abstract class Test {

package/{src → dist}/Test.js

@@ -1,42 +1,27 @@
 "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 config_1 = __importDefault(require("./config"));
+const logger_1 = __importDefault(require("./logger"));
 /**
  * @see https://stackoverflow.com/questions/13651945/what-is-the-use-of-module-parent-in-node-js-how-can-i-refer-to-the-requireing
  */
 delete require.cache[__filename];
 class Test {
-    constructor() {
-        this.tests = [];
-    }
-    run(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result = null;
-            try {
-                result = yield this.test(params);
-            }
-            catch (err) {
-                console.error(err);
-                result = {
-                    status: 'ERROR',
-                    title: test.name,
-                    description: 'Test failed or cannot be run!',
-                };
-            }
-            return result;
+    tests = [];
+    async run(params) {
+        logger_1.default.debug(`Running ${this.name} tests...`);
+        const result = await this.test(params).catch((err) => {
+            console.error(err);
+            return {
+                status: 'ERROR',
+                title: test.name,
+                description: 'Test failed or cannot be run!',
+            };
         });
+        return result;
     }
     getTests() {
         return this.tests.filter((test) => {

package/{src → dist}/commands/Sitemap.d.ts

@@ -31,10 +31,10 @@
  */
 declare class Sitemap {
     run(url: string): Promise<string[]>;
-    protected searchSitemaps(url: string): Promise<void>;
-    protected loadSitemap(url: string): Promise<ISitemap>;
-    protected isIndex(sitemap: any): boolean;
+    protected searchSitemaps(): Promise<void>;
+    protected loadSitemap(url: string): Promise<SitemapFile>;
+    protected isIndex(sitemap: SitemapFile): boolean;
     protected getSitemapUrls(sitemapIndex: any): string[];
-    protected loadMultiple(sitemapUrls: string[]): Promise<ISitemap>;
+    protected loadMultiple(sitemapUrls: string[]): Promise<SitemapFile>;
 }
 export default Sitemap;

package/dist/commands/Sitemap.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = __importDefault(require("../request"));
+const functions_1 = require("../functions");
+/**
+ * Check URL if contains sitemap data. If URL is not direct link
+ * to *.xml file, it will try to search it. For example by default
+ * it is located in the root of the page (/sitemap.xml) or it can
+ * be mentioned in /robots.txt.
+ *
+ * There are 2 types of sitemap. One is common, which starts with
+ * <urlset> tag and then there is sitemap index, wich is used
+ * to group multiple sitemap files. This starts with <sitemapindex>
+ * tag.
+ *
+ * Example:
+ *
+ * <?xml version="1.0" encoding="utf-8"?>
+ * <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+ *  <url>
+ *    <loc>http://example.com/</loc>
+ *  </url>
+ * </urlset>
+ *
+ * <?xml version="1.0" encoding="UTF-8"?>
+ * <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+ *  <sitemap>
+ *    <loc>http://www.example.com/sitemap.xml</loc>
+ *  </sitemap>
+ * </sitemapindex>
+ *
+ * @see https://en.wikipedia.org/wiki/Sitemaps
+ * @see https://www.sitemaps.org/protocol.html
+ * @see https://technicalseo.com/tools/docs/robots-txt/
+ */
+class Sitemap {
+    async run(url) {
+        /*
+        if (!url.endsWith('.xml')) {}
+        */
+        const sitemap = await this.loadSitemap(url);
+        // console.log(sitemap);
+        return sitemap.urlset.url.map((line) => line.loc[0]);
+    }
+    async searchSitemaps() {
+        // check /sitemap.xml
+        // check /robots.txt
+    }
+    async loadSitemap(url) {
+        const xml = await request_1.default.get(url);
+        const sitemap = await (0, functions_1.parseXml)(xml);
+        if (!this.isIndex(sitemap)) {
+            return sitemap;
+        }
+        const sitemapUrls = this.getSitemapUrls(sitemap);
+        return this.loadMultiple(sitemapUrls);
+    }
+    isIndex(sitemap) {
+        return 'sitemapindex' in sitemap;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    getSitemapUrls(sitemapIndex) {
+        /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+        return sitemapIndex.sitemapindex.sitemap.map((sitemap) => sitemap.loc[0]);
+    }
+    async loadMultiple(sitemapUrls) {
+        const sitemaps = await Promise.all(sitemapUrls.map(async (sitemapUrl) => await this.loadSitemap(sitemapUrl)));
+        const urls = sitemaps.map((s) => s.urlset.url).reduce((arr, s) => arr.concat(s), []);
+        return {
+            urlset: {
+                url: urls,
+            },
+        };
+    }
+}
+exports.default = Sitemap;

package/dist/dns/A.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dns_1 = __importDefault(require("dns"));
+const whois_1 = __importDefault(require("whois"));
+const Test_1 = __importDefault(require("../Test"));
+const logger_1 = __importDefault(require("../logger"));
+class A extends Test_1.default {
+    name = 'A';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const response = await new Promise((resolve, reject) => {
+            dns_1.default.lookup((new URL(url).hostname), { all: true }, (err, addresses) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(addresses);
+            });
+        });
+        /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+        const addresses = await Promise.all(response.map(async (address) => {
+            const organization = await this.getOrganization(address.address);
+            return `${address.address} - ${organization}`;
+        }));
+        return {
+            status: 'SUCCESS',
+            title: this.constructor.name,
+            description: addresses.join('\n'),
+        };
+    }
+    async getOrganization(ip) {
+        const organization = await new Promise((resolve, reject) => {
+            whois_1.default.lookup(ip, function (err, data) {
+                if (err) {
+                    return reject(err);
+                }
+                const organization = (typeof data === 'string' ? data.split('\n') : data)
+                    .filter((line) => line.includes('OrgName'))
+                    .map((line) => line.split(':')[1].trim())
+                    .pop();
+                resolve(organization);
+            });
+        });
+        return organization;
+    }
+}
+exports.default = A;

package/dist/dns/DMARC.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dns_1 = __importDefault(require("dns"));
+const Test_1 = __importDefault(require("../Test"));
+const logger_1 = __importDefault(require("../logger"));
+const getDomain_1 = __importDefault(require("../functions/getDomain"));
+class DMARC extends Test_1.default {
+    name = 'DMARC';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+        const response = await new Promise((resolve, reject) => {
+            dns_1.default.resolveTxt(`_dmarc.${(0, getDomain_1.default)(url)}`, (err, records) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(records);
+            });
+        });
+        if (response.length === 0) {
+            return {
+                status: 'WARNING',
+                title: this.constructor.name,
+                description: 'No DMARC record found for this domain.',
+            };
+        }
+        const record = response.shift().shift();
+        if (record.includes('p=none')) {
+            return {
+                status: 'ERROR',
+                title: this.constructor.name,
+                description: 'Email that fails DMARC Compliance tests will be delivered to the recipient\'s inbox.',
+            };
+        }
+        if (record.includes('p=quarantine')) {
+            return {
+                status: 'WARNING',
+                title: this.constructor.name,
+                description: 'Email that fails DMARC Compliance tests will be marked as spam.',
+            };
+        }
+        if (record.includes('p=reject')) {
+            return {
+                status: 'SUCCESS',
+                title: this.constructor.name,
+                description: 'Email that fails DMARC Compliance tests will be rejected.',
+            };
+        }
+        return {
+            status: 'ERROR',
+            title: this.constructor.name,
+            description: 'Invalid DMARC policy found!',
+        };
+    }
+}
+exports.default = DMARC;

package/dist/dns/NS.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whois_1 = __importDefault(require("whois"));
+const Test_1 = __importDefault(require("../Test"));
+const logger_1 = __importDefault(require("../logger"));
+const getDomain_1 = __importDefault(require("../functions/getDomain"));
+class NS extends Test_1.default {
+    name = 'NS';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const nameServers = await this.getNameServers((0, getDomain_1.default)(url));
+        return {
+            status: 'SUCCESS',
+            title: this.constructor.name,
+            description: nameServers.join('\n'),
+        };
+    }
+    async getNameServers(domain) {
+        const nameServers = await new Promise((resolve, reject) => {
+            whois_1.default.lookup(domain, function (err, data) {
+                if (err) {
+                    return reject(err);
+                }
+                const nameServers = (typeof data === 'string' ? data.split('\n') : data)
+                    .filter((line) => line.includes('Name Server'))
+                    .map((line) => line.split(':')[1].trim());
+                resolve(nameServers);
+            });
+        });
+        return nameServers;
+    }
+}
+exports.default = NS;

package/dist/dns/RegistrationDate.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whois_1 = __importDefault(require("whois"));
+const Test_1 = __importDefault(require("../Test"));
+const logger_1 = __importDefault(require("../logger"));
+const getDomain_1 = __importDefault(require("../functions/getDomain"));
+class RegistrationDate extends Test_1.default {
+    name = 'RegistrationDate';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const registrationDate = await this.getRegistrationDate((0, getDomain_1.default)(url));
+        const diffInMs = (new Date(registrationDate)).getTime() - (new Date()).getTime();
+        const diffInDays = diffInMs / (1000 * 60 * 60 * 24);
+        return {
+            status: diffInDays < 7 ? 'ERROR' : diffInDays < 30 ? 'WARNING' : 'SUCCESS',
+            title: this.constructor.name,
+            description: `Approximately ${Math.floor(diffInDays)} days until domain expires.`,
+        };
+    }
+    async getRegistrationDate(domain) {
+        const date = await new Promise((resolve, reject) => {
+            whois_1.default.lookup(domain, function (err, data) {
+                if (err) {
+                    return reject(err);
+                }
+                const d = (typeof data === 'string' ? data.split('\n') : data)
+                    .filter((line) => line.includes('Expiration Date') || line.includes('Valid Until'))
+                    .map((line) => line.split(': ')[1].trim())
+                    .shift();
+                resolve(d);
+            });
+        });
+        return date;
+    }
+}
+exports.default = RegistrationDate;

package/dist/dns/index.js

@@ -0,0 +1,47 @@
+"use strict";
+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 A_1 = __importDefault(require("./A"));
+const NS_1 = __importDefault(require("./NS"));
+const DMARC_1 = __importDefault(require("./DMARC"));
+const RegistrationDate_1 = __importDefault(require("./RegistrationDate"));
+class DNS extends Test_1.default {
+    name = 'DNS';
+    constructor() {
+        super();
+        this.tests = [
+            new RegistrationDate_1.default(),
+            new NS_1.default(),
+            new A_1.default(),
+            new DMARC_1.default(),
+        ];
+    }
+    async test(params) {
+        const tests = this.getTests();
+        const results = [];
+        for (const test of tests) {
+            let result = null;
+            try {
+                result = await test.run(params);
+            }
+            catch {
+                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 = DNS;

package/dist/functions/findEvery.d.ts

@@ -0,0 +1,2 @@
+declare const find: (object: unknown, test: (object: unknown) => boolean) => unknown;
+export default find;

package/{src → dist}/functions/getDuplicates.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const htmlparser2_1 = require("htmlparser2");
+/* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
 function default_1(result) {
     return new Promise((resolve) => {
         let elementsWithId = [];

package/dist/functions/getGenerator.d.ts

@@ -0,0 +1,2 @@
+declare const getGenerator: (result: UnknownObject) => UnknownObject[];
+export default getGenerator;

package/{src → dist}/functions/getGenerator.js

@@ -12,6 +12,9 @@ const getGenerator = (result) => {
             Object.prototype.hasOwnProperty.call(meta.attribs, 'content');
     })
         .filter((meta) => {
+        if ('attribs' in meta === false || typeof meta.attribs !== 'object' || 'name' in meta.attribs === false || typeof meta.attribs.name !== 'string') {
+            return false;
+        }
         return meta.attribs.name === 'generator';
     });
 };

package/{src → dist}/functions/getHeading.js

@@ -4,7 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getObject_1 = __importDefault(require("./getObject"));
+/* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
 const getHeading = (result) => {
+    if (typeof result === 'object' && 'html' in result === false) {
+        throw new Error('The result object does not contain an HTML property.');
+    }
     const titles = (0, getObject_1.default)(result.html, 'name', 'h1')
         .map((title) => {
         return title.children[0].data;

package/{src → dist}/functions/getImages.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const url_1 = require("url");
 const getObject_1 = __importDefault(require("./getObject"));
+/* eslint-disable  @typescript-eslint/no-explicit-any */
 const getImages = (result) => {
     const origin = (new url_1.URL(result.url)).origin;
     return (0, getObject_1.default)(result.html, 'name', 'img')

package/dist/functions/getObject.d.ts

@@ -0,0 +1,2 @@
+declare const getObject: (theObject: UnknownObject, key: string, value: string) => UnknownObject[];
+export default getObject;

package/{src → dist}/functions/getScripts.js

@@ -15,6 +15,7 @@ const getObject_1 = __importDefault(require("./getObject"));
  * It returns an array of links to JavaScript files. Every URL
  * is full URL.
  */
+/* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
 const getScripts = (result) => {
     const origin = (new url_1.URL(result.url)).origin;
     return (0, getObject_1.default)(result.html, 'type', 'script')

package/{src → dist}/functions/getStylesheets.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const url_1 = require("url");
 const getObject_1 = __importDefault(require("./getObject"));
+/* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
 const getStylesheets = (result) => {
     const origin = (new url_1.URL(result.url)).origin;
     return (0, getObject_1.default)(result.html, 'name', 'link')

package/{src → dist}/functions/getTitle.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getObject_1 = __importDefault(require("./getObject"));
+/* eslint-disable  @typescript-eslint/no-explicit-any */
 const getTitle = (result) => {
     const titles = (0, getObject_1.default)(result.html, 'name', 'title')
         .map((title) => {

package/{src → dist}/functions/parseHtml.js

@@ -6,9 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const domhandler_1 = __importDefault(require("domhandler"));
 const htmlparser2_1 = require("htmlparser2");
+/* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
 function default_1(result) {
     return new Promise((resolve, reject) => {
         const handler = new domhandler_1.default((error, dom) => {
+            if (error) {
+                reject(error);
+            }
             resolve({
                 html: dom,
                 url: result.url,

package/dist/functions/parseSitemap.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const parseXml_1 = __importDefault(require("./parseXml"));
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+async function default_1(sitemap) {
+    const data = await (0, parseXml_1.default)(sitemap);
+    return data.urlset.url.map((url) => url.loc[0]);
+}

package/dist/html/Anchor.js

@@ -0,0 +1,56 @@
+"use strict";
+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"));
+const functions_1 = require("../functions");
+class Anchor extends Test_1.default {
+    name = 'Anchor';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const response = await request_1.default.get(url);
+        const html = await (0, functions_1.parseHtml)(response);
+        const anchors = (0, functions_1.getAnchors)(html);
+        const subTests = await this.check(anchors);
+        return {
+            status: this.getStatus(subTests.map(test => test.status)),
+            title: this.constructor.name,
+            description: '',
+            results: subTests,
+        };
+    }
+    async check(anchors) {
+        const results = [];
+        for (const anchor of anchors) {
+            logger_1.default.verbose(`Checking ${anchor}...`);
+            const result = await request_1.default.get(anchor);
+            const isFileAvailabe = {
+                status: this.isFileAvailable(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Available',
+                description: '',
+            };
+            results.push({
+                status: this.getStatus([
+                    isFileAvailabe.status,
+                ]), // eslint-disable-line  @typescript-eslint/no-explicit-any
+                title: anchor,
+                description: '',
+                results: [
+                    isFileAvailabe,
+                ],
+            });
+        }
+        return results;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isFileAvailable(result) {
+        if (result.response.statusCode === 404 || result.response.statusCode === 500) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.default = Anchor;