greybel-mock-environment 1.0.3 → 1.0.5

package/dist/default-fs.d.ts

@@ -1,3 +1,3 @@
-import { FileSystemEntity, Folder, User } from './types';
-export declare function getUserFolder(parent: FileSystemEntity, user: string): Folder;
+import { Folder, FSEntity, User } from './types';
+export declare function getUserFolder(parent: FSEntity, user: string): Folder;
 export declare function getDefaultFileSystem(users: User[]): Folder;

package/dist/environment.d.ts

@@ -1,59 +1,29 @@
-import { RandomSeed } from 'random-seed';
-import { Computer, EMail, Library, Network, NetworkDevice, Port, Router, User, Vulnerability } from './types';
+import BasicGenerator from './generators/basic';
+import EmailGenerator from './generators/email';
+import NetworkGenerator from './generators/network';
+import UserGenerator from './generators/user';
+import VulnerabilityGenerator from './generators/vulnerability';
+import { Computer, EMail, Port, Router, Switch, User } from './types';
 export default class MockEnvironment {
     seed: string;
-    vulnerabilityRng: RandomSeed;
-    bankIdRng: RandomSeed;
-    networkRng: RandomSeed;
-    macAddressRng: RandomSeed;
-    uuidRng: RandomSeed;
-    passwordRng: RandomSeed;
-    usernameRng: RandomSeed;
-    portRng: RandomSeed;
-    users: User[];
-    routers: Router[];
-    computers: Computer[];
-    vulnerabilities: Vulnerability[];
-    networks: Network[];
-    emails: EMail[];
+    basicGenerator: BasicGenerator;
+    emailGenerator: EmailGenerator;
+    userGenerator: UserGenerator;
+    vulnerabilityGenerator: VulnerabilityGenerator;
+    networkGenerator: NetworkGenerator;
     localComputer: Computer;
     constructor(seed: string, localUser: {
         username: string;
         password: string;
     });
-    generateUser(username: string, password: string): User;
-    generateDomain(): string;
-    generateEmail(options: {
-        name?: string;
-        domain?: string;
-        password?: string;
-    }): string;
-    generateRouter(options?: Partial<Router>): Router;
-    generateComputer(router: Router | null, users: User[], rootPassword?: string): Computer;
-    generatePorts(computer: Computer): Port[];
     getComputerInLan(ipAddress: string, router: Router): Computer | null;
     getComputersOfRouter(router: Router): Computer[];
     getPortsOfRouter(router: Router): Port[];
     getForwardedPortsOfRouter(router: Router): Port[];
     getForwardedPortOfRouter(router: Router, port: number): {
-        computer: Computer;
         port: Port;
+        computer: Computer;
     } | null;
-    generateNetworkDevice(): NetworkDevice;
-    generateIp(): string;
-    generateLocalIp(): string;
-    generateMAC(): string;
-    generateUUID(): string;
-    generateUsername(): string;
-    generatePassword(): string;
-    generateNetwork(router: Router, options?: Partial<Network>): Network;
-    generateVulnerabilityAddress(): string;
-    generateVulnerability(library: Library, memAddress: string, remote: boolean): Vulnerability;
-    generateSectorVulnerabilities(library: Library, sector: string, remote: boolean): Vulnerability[];
-    generateVulnerabilitiesForLibrary(library: Library, options?: {
-        remote?: boolean;
-        local?: boolean;
-    }): void;
     setupLibraries(): void;
     getLocal(): {
         computer: Computer;
@@ -61,10 +31,9 @@ export default class MockEnvironment {
     };
     connectLocal(router: Router): void;
     getRouterByIp(ipAddress: string): Router | null;
+    getSwitchByIp(ipAddress: string): Switch | null;
     getComputersOfRouterByIp(ipAddress: string): Computer[];
     findRouterViaNS(name: string): Router;
     getEmailViaLogin(email: string, password: string): EMail | null;
     getEmail(email: string): EMail | null;
-    isValidIp(target: string): boolean;
-    isLanIp(target: string): boolean;
 }

package/dist/environment.js

@@ -1,4 +1,15 @@
 "use strict";
+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 __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -15,157 +26,43 @@ var __read = (this && this.__read) || function (o, n) {
     }
     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 = require("./default-fs");
+var basic_1 = __importDefault(require("./generators/basic"));
+var email_1 = __importDefault(require("./generators/email"));
+var network_1 = __importDefault(require("./generators/network"));
+var user_1 = __importDefault(require("./generators/user"));
+var vulnerability_1 = __importDefault(require("./generators/vulnerability"));
 var types_1 = require("./types");
-var randomUsernameGenerator = require('random-username-generator');
+var utils_1 = require("./utils");
 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');
+        this.basicGenerator = new basic_1.default({ seed: seed });
+        this.emailGenerator = new email_1.default({
+            seed: seed,
+            basicGenerator: this.basicGenerator
+        });
+        this.userGenerator = new user_1.default({
+            seed: seed,
+            basicGenerator: this.basicGenerator,
+            emailGenerator: this.emailGenerator
+        });
+        this.vulnerabilityGenerator = new vulnerability_1.default({
+            seed: seed,
+            basicGenerator: this.basicGenerator
+        });
+        this.networkGenerator = new network_1.default({
+            seed: seed,
+            basicGenerator: this.basicGenerator,
+            userGenerator: this.userGenerator,
+            emailGenerator: this.emailGenerator
+        });
+        this.localComputer = this.networkGenerator.generateLocalComputer([this.userGenerator.generate(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.getDefaultFileSystem)(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.getDefaultFileSystem)(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) {
@@ -173,240 +70,67 @@ var MockEnvironment = /** @class */ (function () {
         });
     };
     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;
-        });
+        return Array.from(router.devices.values()).filter(function (d) { return d instanceof types_1.Computer; });
     };
     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));
+        return Array.from(router.ports.values());
     };
     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) {
+        var computers = me.getComputersOfRouter(router);
+        var computer = computers.find(function (c) { return c.ports.has(port); });
+        if (!computer) {
             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']
+            computer: computer,
+            port: computer.ports.get(port)
         };
     };
-    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, {
+        var vulnerabilityGenerator = me.vulnerabilityGenerator;
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.CRYPTO, {
+            local: true
+        });
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.FTP, {
             local: true,
             remote: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.HTTP, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.HTTP, {
             local: true,
             remote: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.INIT, { local: true });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.KERNEL_MODULE, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.INIT, {
+            local: true
+        });
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.KERNEL_MODULE, {
             local: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.KERNEL_ROUTER, {
+        vulnerabilityGenerator.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, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.METAXPLOIT, { local: true });
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.NET, {
+            local: true
+        });
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.RSHELL, {
             local: true,
             remote: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.SMTP, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.SMTP, {
             local: true,
             remote: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.SQL, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.SQL, {
             local: true,
             remote: true
         });
-        me.generateVulnerabilitiesForLibrary(types_1.Library.SSH, {
+        vulnerabilityGenerator.generateVulnerabilitiesForLibrary(types_1.Library.SSH, {
             local: true,
             remote: true
         });
@@ -420,19 +144,57 @@ var MockEnvironment = /** @class */ (function () {
         };
     };
     MockEnvironment.prototype.connectLocal = function (router) {
-        this.localComputer.router = router;
+        var me = this;
+        var serverMap = me.networkGenerator.serverMap;
+        if (!serverMap.has(router.publicIp)) {
+            throw new Error("Router with ip ".concat(router.publicIp, " is unknown in serverMap."));
+        }
+        var localComputer = me.localComputer;
+        if (localComputer.router) {
+            localComputer.router.devices.delete(localComputer.localIp);
+        }
+        var serverMapGenerator = serverMap.get(router.publicIp);
+        var localIp = serverMapGenerator.generateLocalIp(router);
+        localComputer.router = router;
+        localComputer.localIp = localIp;
+        router.devices.set(localIp, localComputer);
     };
     MockEnvironment.prototype.getRouterByIp = function (ipAddress) {
         var me = this;
-        if (!me.isValidIp(ipAddress)) {
+        if ((0, utils_1.isValidIp)(ipAddress)) {
             return null;
         }
-        return (me.routers.find(function (item) {
-            return item.publicIp === ipAddress;
-        }) ||
-            me.generateRouter({
-                publicIp: ipAddress
-            }));
+        var serverMap = me.networkGenerator.serverMap;
+        if (serverMap.has(ipAddress)) {
+            return serverMap.get(ipAddress).router;
+        }
+        return me.networkGenerator.generateRouter({
+            publicIp: ipAddress
+        });
+    };
+    MockEnvironment.prototype.getSwitchByIp = function (ipAddress) {
+        var e_1, _a;
+        var me = this;
+        if (!(0, utils_1.isValidIp)(ipAddress) || !(0, utils_1.isLanIp)(ipAddress)) {
+            return null;
+        }
+        var localRouter = me.localComputer.router;
+        try {
+            for (var _b = __values(localRouter.devices), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), localIp = _d[0], device = _d[1];
+                if (localIp === ipAddress && device instanceof types_1.Switch) {
+                    return device;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return null;
     };
     MockEnvironment.prototype.getComputersOfRouterByIp = function (ipAddress) {
         var me = this;
@@ -440,29 +202,26 @@ var MockEnvironment = /** @class */ (function () {
         if (!router) {
             return [];
         }
-        return me.computers.filter(function (v) {
-            return v.router.publicIp === router.publicIp;
-        });
+        var devices = Array.from(router.devices.values());
+        return devices.filter(function (d) { return d instanceof types_1.Computer; });
     };
     MockEnvironment.prototype.findRouterViaNS = function (name) {
         var me = this;
-        return me.routers.find(function (item) {
+        var serverMap = me.networkGenerator.serverMap;
+        var routers = Array.from(serverMap.values()).map(function (g) { return g.router; });
+        return 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; });
+        var emails = me.emailGenerator.emails;
+        return 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);
+        var emails = me.emailGenerator.emails;
+        return emails.find(function (v) { return v.email === email; });
     };
     return MockEnvironment;
 }());