greybel-mock-environment 1.0.0

package/dist/environment.js

@@ -0,0 +1,469 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var blueimp_md5_1 = __importDefault(require("blueimp-md5"));
+var random_seed_1 = __importDefault(require("random-seed"));
+var default_fs_1 = __importDefault(require("./default-fs"));
+var types_1 = require("./types");
+var randomUsernameGenerator = require('random-username-generator');
+var MockEnvironment = /** @class */ (function () {
+    function MockEnvironment(seed, localUser) {
+        if (seed === void 0) { seed = 'test'; }
+        this.seed = seed;
+        this.vulnerabilityRng = random_seed_1.default.create("".concat(seed, "-vul-number"));
+        this.bankIdRng = random_seed_1.default.create("".concat(seed, "-bank-number"));
+        this.networkRng = random_seed_1.default.create("".concat(seed, "-network-devices"));
+        this.macAddressRng = random_seed_1.default.create("".concat(seed, "-mac-address"));
+        this.uuidRng = random_seed_1.default.create("".concat(seed, "-uuid"));
+        this.passwordRng = random_seed_1.default.create("".concat(seed, "-password"));
+        this.usernameRng = random_seed_1.default.create("".concat(seed, "-username"));
+        this.portRng = random_seed_1.default.create("".concat(seed, "-port"));
+        this.users = [];
+        this.routers = [];
+        this.computers = [];
+        this.vulnerabilities = [];
+        this.networks = [];
+        this.emails = [];
+        this.localComputer = this.generateComputer(null, [this.generateUser(localUser.username, localUser.password)], 'test');
+    }
+    MockEnvironment.prototype.generateUser = function (username, password) {
+        var me = this;
+        var user = {
+            username: username,
+            password: password,
+            passwordHashed: (0, blueimp_md5_1.default)(password),
+            email: me.generateEmail({
+                name: username,
+                password: password
+            }),
+            userBankNumber: me.bankIdRng.random().toString(36).substring(2, 10)
+        };
+        me.users.push(user);
+        return user;
+    };
+    MockEnvironment.prototype.generateDomain = function () {
+        var me = this;
+        return "".concat(me.generateUsername(), ".").concat(['org', 'com', 'de', 'tv'][me.networkRng.intBetween(0, 3)]);
+    };
+    MockEnvironment.prototype.generateEmail = function (options) {
+        var me = this;
+        var email = "".concat(options.name || me.generateUsername(), "@").concat(options.domain || me.generateDomain());
+        me.emails.push({
+            email: email,
+            password: options.password || me.generatePassword(),
+            messages: new Map()
+        });
+        return email;
+    };
+    MockEnvironment.prototype.generateRouter = function (options) {
+        if (options === void 0) { options = {}; }
+        var me = this;
+        var networkDevice = me.generateNetworkDevice();
+        var routerUsers = [
+            me.generateUser('root', me.generatePassword()),
+            me.generateUser(me.generateUsername(), me.generatePassword())
+        ];
+        var domain = me.generateDomain();
+        var name = me.generateUsername();
+        var router = {
+            domain: options.domain || "www.".concat(domain),
+            whoisDescription: options.whoisDescription ||
+                [
+                    "Domain name: ".concat(domain),
+                    "Administrative contact: ".concat(name),
+                    "Email address: ".concat(me.generateEmail({ name: name, domain: domain })),
+                    'Phone: 123456891'
+                ].join('\n'),
+            publicIp: options.publicIp || me.generateIp(),
+            localIp: options.localIp || me.generateLocalIp(),
+            activeNetCard: options.activeNetCard || networkDevice.type,
+            networkDevices: options.networkDevices || [networkDevice],
+            users: options.users || routerUsers,
+            fileSystem: options.fileSystem || (0, default_fs_1.default)(routerUsers)
+        };
+        for (var index = me.networkRng.intBetween(4, 10); index >= 0; index--) {
+            me.generateComputer(router, [
+                me.generateUser(me.generateUsername(), me.generatePassword())
+            ]);
+        }
+        me.routers.push(router);
+        return router;
+    };
+    MockEnvironment.prototype.generateComputer = function (router, users, rootPassword) {
+        var me = this;
+        var networkDevice = me.generateNetworkDevice();
+        var computerUsers = __spreadArray([
+            me.generateUser('root', rootPassword || me.generatePassword())
+        ], __read(users), false);
+        var computer = {
+            router: router,
+            localIp: me.generateLocalIp(),
+            activeNetCard: networkDevice.type,
+            networkDevices: [networkDevice],
+            users: computerUsers,
+            fileSystem: (0, default_fs_1.default)(computerUsers),
+            ports: []
+        };
+        computer.ports = me.generatePorts(computer);
+        me.computers.push(computer);
+        return computer;
+    };
+    MockEnvironment.prototype.generatePorts = function (computer) {
+        var me = this;
+        var portNumber = me.portRng.intBetween(1, 1000);
+        var router = computer.router;
+        var forwarded = false;
+        if (router) {
+            var forwardedPort = me.getForwardedPortOfRouter(router, portNumber);
+            if (!forwardedPort) {
+                forwarded = me.networkRng.intBetween(0, 2) === 1;
+            }
+        }
+        return __spreadArray([], __read(Array(me.portRng.intBetween(1, 3)).keys()), false).map(function () {
+            return {
+                port: me.portRng.intBetween(1, 1000),
+                isClosed: !!me.portRng.intBetween(0, 1),
+                service: types_1.ServiceList[me.portRng.intBetween(0, 5)],
+                forwarded: forwarded
+            };
+        });
+    };
+    MockEnvironment.prototype.getComputerInLan = function (ipAddress, router) {
+        var me = this;
+        return me.getComputersOfRouter(router).find(function (v) {
+            return v.localIp === ipAddress;
+        });
+    };
+    MockEnvironment.prototype.getComputersOfRouter = function (router) {
+        var me = this;
+        return me.computers.filter(function (v) {
+            var _a;
+            return ((_a = v.router) === null || _a === void 0 ? void 0 : _a.publicIp) === router.publicIp;
+        });
+    };
+    MockEnvironment.prototype.getPortsOfRouter = function (router) {
+        var me = this;
+        var computers = me.getComputersOfRouter(router);
+        return [].concat.apply([], __spreadArray([], __read(computers.map(function (v) {
+            return v.ports;
+        })), false));
+    };
+    MockEnvironment.prototype.getForwardedPortsOfRouter = function (router) {
+        var me = this;
+        return me.getPortsOfRouter(router).filter(function (v) { return v.forwarded; });
+    };
+    MockEnvironment.prototype.getForwardedPortOfRouter = function (router, port) {
+        var e_1, _a, e_2, _b;
+        var me = this;
+        var computers = me.computers.filter(function (v) {
+            var _a;
+            return ((_a = v.router) === null || _a === void 0 ? void 0 : _a.publicIp) === router.publicIp;
+        });
+        var computerResult;
+        var portResult;
+        try {
+            for (var computers_1 = __values(computers), computers_1_1 = computers_1.next(); !computers_1_1.done; computers_1_1 = computers_1.next()) {
+                var item = computers_1_1.value;
+                if (item.ports) {
+                    try {
+                        for (var _c = (e_2 = void 0, __values(item.ports)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var itemPort = _d.value;
+                            if (itemPort.port === port && itemPort.forwarded) {
+                                computerResult = item;
+                                portResult = itemPort;
+                                break;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                if (computerResult || portResult) {
+                    break;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (computers_1_1 && !computers_1_1.done && (_a = computers_1.return)) _a.call(computers_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (!computerResult || !portResult) {
+            return null;
+        }
+        return {
+            computer: computerResult,
+            port: portResult
+        };
+    };
+    MockEnvironment.prototype.generateNetworkDevice = function () {
+        return {
+            type: this.networkRng.intBetween(0, 1) === 0 ? 'wlan0' : 'eth0',
+            id: this.networkRng.random().toString(36).substring(2, 10),
+            active: true
+        };
+    };
+    MockEnvironment.prototype.generateIp = function () {
+        var me = this;
+        return "".concat(me.networkRng.intBetween(0, 255), ".").concat(me.networkRng.intBetween(0, 255), ".").concat(me.networkRng.intBetween(0, 255), ".").concat(me.networkRng.intBetween(0, 255));
+    };
+    MockEnvironment.prototype.generateLocalIp = function () {
+        var me = this;
+        return "192.168.".concat(me.networkRng.intBetween(0, 255), ".").concat(me.networkRng.intBetween(0, 255));
+    };
+    MockEnvironment.prototype.generateMAC = function () {
+        var me = this;
+        var d = '0123456789ABCDEF';
+        return __spreadArray([], __read(Array(6).keys()), false).map(function () {
+            return (d[me.macAddressRng.intBetween(0, 15)] +
+                d[me.macAddressRng.intBetween(0, 15)]);
+        })
+            .join(':');
+    };
+    MockEnvironment.prototype.generateUUID = function () {
+        var me = this;
+        var dt = me.uuidRng.random();
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = (dt + me.uuidRng.random() * 16) % 16 | 0;
+            dt = Math.floor(dt / 16);
+            return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+        });
+    };
+    MockEnvironment.prototype.generateUsername = function () {
+        var me = this;
+        var nativeMath = Math.random;
+        Math.random = function () { return me.usernameRng.random(); };
+        var username = randomUsernameGenerator.generate();
+        Math.random = nativeMath;
+        return username;
+    };
+    MockEnvironment.prototype.generatePassword = function () {
+        var me = this;
+        return me.passwordRng.string(me.passwordRng.intBetween(4, 8));
+    };
+    MockEnvironment.prototype.generateNetwork = function (router, options) {
+        if (options === void 0) { options = {}; }
+        var me = this;
+        var network = {
+            mac: options.mac || me.generateMAC(),
+            percentage: options.percentage || me.networkRng.intBetween(20, 70),
+            name: options.name || me.generateUsername(),
+            bssid: options.bssid || me.generateUUID(),
+            essid: options.essid || me.generateUUID(),
+            password: options.password || me.generatePassword(),
+            router: router
+        };
+        me.networks.push(network);
+        return network;
+    };
+    MockEnvironment.prototype.generateVulnerabilityAddress = function () {
+        var me = this;
+        var d = '0123456789ABCDEF';
+        return ('0x' +
+            __spreadArray([], __read(Array(8).keys()), false).map(function () {
+                return d[me.vulnerabilityRng.intBetween(0, 15)];
+            })
+                .join(''));
+    };
+    MockEnvironment.prototype.generateVulnerability = function (library, memAddress, remote) {
+        var me = this;
+        var requirementAmount = me.vulnerabilityRng.intBetween(0, 3);
+        var required = [];
+        var action = types_1.VulnerabilityActionList[me.vulnerabilityRng.intBetween(0, 4)];
+        var user;
+        while (required.length < requirementAmount) {
+            var index = me.vulnerabilityRng.intBetween(0, 6);
+            var req = types_1.VulnerabilityRequirementList[index];
+            if (!required.includes(req)) {
+                required.push(req);
+            }
+        }
+        var userType = me.vulnerabilityRng.intBetween(0, 5);
+        switch (userType) {
+            case 0:
+                user = types_1.VulnerabilityActionUser.ROOT;
+                break;
+            case 1:
+            case 2:
+                user = types_1.VulnerabilityActionUser.NORMAL;
+                break;
+            default:
+                user = types_1.VulnerabilityActionUser.GUEST;
+                break;
+        }
+        return {
+            required: required,
+            memAddress: memAddress,
+            sector: me.vulnerabilityRng.random().toString(36).substring(2, 12),
+            details: 'loop in array',
+            remote: remote,
+            library: library,
+            action: action,
+            user: user,
+            folder: ['home', 'guest']
+        };
+    };
+    MockEnvironment.prototype.generateSectorVulnerabilities = function (library, sector, remote) {
+        var _a;
+        var me = this;
+        var vulAmount = me.vulnerabilityRng.intBetween(1, 4);
+        var result = [];
+        for (var index = vulAmount; index >= 0; index--) {
+            result.push(me.generateVulnerability(library, sector, remote));
+        }
+        (_a = this.vulnerabilities).push.apply(_a, __spreadArray([], __read(result), false));
+        return result;
+    };
+    MockEnvironment.prototype.generateVulnerabilitiesForLibrary = function (library, options) {
+        if (options === void 0) { options = {}; }
+        var me = this;
+        var address = me.generateVulnerabilityAddress();
+        for (var amount = me.vulnerabilityRng.intBetween(2, 5); amount >= 0; amount--) {
+            if (options.remote)
+                me.generateSectorVulnerabilities(library, address, true);
+            if (options.local)
+                me.generateSectorVulnerabilities(library, address, false);
+            address =
+                me.vulnerabilityRng.intBetween(0, 3) === 1
+                    ? me.generateVulnerabilityAddress()
+                    : address;
+        }
+    };
+    MockEnvironment.prototype.setupLibraries = function () {
+        var me = this;
+        me.generateVulnerabilitiesForLibrary(types_1.Library.CRYPTO, { local: true });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.FTP, {
+            local: true,
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.HTTP, {
+            local: true,
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.INIT, { local: true });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.KERNEL_MODULE, {
+            local: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.KERNEL_ROUTER, {
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.METAXPLOIT, { local: true });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.NET, { local: true });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.RSHELL, {
+            local: true,
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.SMTP, {
+            local: true,
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.SQL, {
+            local: true,
+            remote: true
+        });
+        me.generateVulnerabilitiesForLibrary(types_1.Library.SSH, {
+            local: true,
+            remote: true
+        });
+    };
+    MockEnvironment.prototype.getLocal = function () {
+        var computer = this.localComputer;
+        var user = computer.users[1];
+        return {
+            computer: computer,
+            user: user
+        };
+    };
+    MockEnvironment.prototype.connectLocal = function (router) {
+        this.localComputer.router = router;
+    };
+    MockEnvironment.prototype.getRouterByIp = function (ipAddress) {
+        var me = this;
+        if (!me.isValidIp(ipAddress)) {
+            return null;
+        }
+        return (me.routers.find(function (item) {
+            return item.publicIp === ipAddress;
+        }) ||
+            me.generateRouter({
+                publicIp: ipAddress
+            }));
+    };
+    MockEnvironment.prototype.getComputersOfRouterByIp = function (ipAddress) {
+        var me = this;
+        var router = me.getRouterByIp(ipAddress);
+        if (!router) {
+            return [];
+        }
+        return me.computers.filter(function (v) {
+            return v.router.publicIp === router.publicIp;
+        });
+    };
+    MockEnvironment.prototype.findRouterViaNS = function (name) {
+        var me = this;
+        return me.routers.find(function (item) {
+            return item.domain === name;
+        });
+    };
+    MockEnvironment.prototype.getEmailViaLogin = function (email, password) {
+        var me = this;
+        return me.emails.find(function (v) { return v.email === email && v.password === password; });
+    };
+    MockEnvironment.prototype.getEmail = function (email) {
+        var me = this;
+        return me.emails.find(function (v) { return v.email === email; });
+    };
+    MockEnvironment.prototype.isValidIp = function (target) {
+        return /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(target);
+    };
+    MockEnvironment.prototype.isLanIp = function (target) {
+        return /^1(0|27|69\.254|72\.(1[6-9]|2[0-9]|3[0-1])|92\.168)\./.test(target);
+    };
+    return MockEnvironment;
+}());
+exports.default = MockEnvironment;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as getDefaultFileSystem } from './default-fs';
+export { default as MockEnvironment } from './environment';
+export * as Type from './types';

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.MockEnvironment = exports.getDefaultFileSystem = void 0;
+var default_fs_1 = require("./default-fs");
+Object.defineProperty(exports, "getDefaultFileSystem", { enumerable: true, get: function () { return __importDefault(default_fs_1).default; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "MockEnvironment", { enumerable: true, get: function () { return __importDefault(environment_1).default; } });
+exports.Type = __importStar(require("./types"));

package/dist/types.d.ts

@@ -0,0 +1,152 @@
+export interface User {
+    username: string;
+    password: string;
+    passwordHashed: string;
+    email: string;
+    userBankNumber: string;
+}
+export declare enum Service {
+    SSH = "ssh",
+    FTP = "ftp",
+    SMTP = "smtp",
+    SQL = "sql",
+    RSHELL = "rshell",
+    HTTP = "http"
+}
+export declare const ServiceList: Service[];
+export interface Port {
+    port: number;
+    isClosed: boolean;
+    service: Service;
+    forwarded: boolean;
+}
+export interface EMail {
+    email: string;
+    password: string;
+    messages: Map<string, {
+        subject: string;
+        message: string;
+    }>;
+}
+export interface NetworkDevice {
+    type: string;
+    id: string;
+    active: boolean;
+}
+export interface Computer {
+    router?: Router;
+    localIp: string;
+    activeNetCard: string;
+    networkDevices: NetworkDevice[];
+    users: User[];
+    fileSystem: Folder;
+    ports?: Port[];
+}
+export interface Router extends Computer {
+    publicIp: string;
+    domain: string;
+    whoisDescription: string;
+}
+export interface Network {
+    bssid: string;
+    essid: string;
+    password: string;
+    router: Router;
+    mac: string;
+    percentage: number;
+    name: string;
+}
+export interface RouterNamespace {
+    name: string;
+    router: Router;
+}
+export declare enum FileType {
+    Plain = 0,
+    Bin = 1,
+    Exe = 2,
+    Crypto = 3,
+    Metaxploit = 4,
+    System = 5,
+    AptClient = 6,
+    Ack = 7,
+    Net = 8,
+    Init = 9,
+    KernelModule = 10,
+    Blockchain = 11,
+    SSH = 12,
+    FTP = 13,
+    HTTP = 14,
+    Chat = 15,
+    RShell = 16,
+    Repository = 17
+}
+export interface FileSystemEntity {
+    parent?: FileSystemEntity;
+    name: string;
+    permissions: string;
+    owner: string;
+    isFolder?: boolean;
+    isProtected?: boolean;
+    deleted?: boolean;
+}
+export interface File extends FileSystemEntity {
+    content?: string;
+    type: FileType;
+}
+export interface Folder extends FileSystemEntity {
+    files: File[];
+    folders: Folder[];
+}
+export declare enum Library {
+    SSH = "ssh",
+    FTP = "ftp",
+    HTTP = "http",
+    SQL = "sql",
+    SMTP = "smtp",
+    CHAT = "chat",
+    CAM = "cam",
+    RSHELL = "rshell",
+    KERNEL_ROUTER = "kernel_router",
+    APT = "apt",
+    METAXPLOIT = "metaxploit",
+    CRYPTO = "crypto",
+    KERNEL_MODULE = "kernel_module",
+    INIT = "init",
+    NET = "net"
+}
+export declare enum VulnerabilityRequirements {
+    LIBRARY = 0,
+    REGISTER_AMOUNT = 1,
+    ANY_ACTIVE = 2,
+    ROOT_ACTIVE = 3,
+    LOCAL = 4,
+    FORWARD = 5,
+    GATEWAY = 6
+}
+export declare const VulnerabilityRequirementList: VulnerabilityRequirements[];
+export declare enum VulnerabilityAction {
+    SHELL = 0,
+    FOLDER = 1,
+    PASSWORD = 2,
+    COMPUTER = 3,
+    FIREWALL = 4
+}
+export declare const VulnerabilityActionList: VulnerabilityAction[];
+export declare enum VulnerabilityActionUser {
+    GUEST = 0,
+    NORMAL = 1,
+    ROOT = 2
+}
+export interface Vulnerability {
+    required: VulnerabilityRequirements[];
+    sector: string;
+    details: string;
+    remote?: boolean;
+    library: Library;
+    action: VulnerabilityAction;
+    user: VulnerabilityActionUser;
+    folder: string[];
+    memAddress: string;
+}
+export interface MockData {
+}