Пример #1
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

            if (user != null && user.isAuthorized && linuxSystem.IsConnectedTheInternet &&
                linuxSystem != null)
            {
                string[] commandParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                User     victimUser    = await _unitOfWork.UserAccessRepository.GetByLinuxSystemIP(commandParams[1]);

                if (commandParams[0] == Name && victimUser != null)
                {
                    await client.SendTextMessageAsync(chatId, "<code>Поиск пользователей...</code>", ParseMode.Html);

                    await client.SendTextMessageAsync(chatId, $"<code>Login: {victimUser.UserName}</code>", ParseMode.Html);

                    return(true);
                }

                await client.SendTextMessageAsync(chatId, "<code>Неверный ip адрес или название команды.</code>", ParseMode.Html);

                return(false);
            }

            await client.SendTextMessageAsync(chatId, "<code>Произошла ошибка</code>", ParseMode.Html);

            return(false);
        }
Пример #2
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null)
                {
                    CurrentDirectory currentDirectory = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                    if (currentDirectory != null)
                    {
                        Directory directory = await _unitOfWork.DirectoryRepository.GetByIdAsync(currentDirectory.DirectoryId);

                        await client.SendTextMessageAsync(chatId, $"<code>{directory.Path}</code>", ParseMode.Html);

                        return(true);
                    }

                    return(false);
                }

                return(false);
            }

            return(false);
        }
Пример #3
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null)
                {
                    string[] commandParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    if (commandParams.Length == 2 && commandParams[0] == Name)
                    {
                        LinuxSystem victimSystem = await _unitOfWork.LinuxRepository.GetByIP(commandParams[1]);

                        if (victimSystem != null)
                        {
                            List <Vulnerability> vulnerabilities = _unitOfWork.VulnerabilityRepository.GetVulnerabilitiesByLinuxSystemId(victimSystem.Id);
                            if (vulnerabilities.Count > 0)
                            {
                                StringBuilder nmapInfo = new StringBuilder();

                                nmapInfo.Append("PORT       STATE\n");
                                foreach (var vulnerabiliti in vulnerabilities)
                                {
                                    foreach (var port in vulnerabiliti.Ports)
                                    {
                                        nmapInfo.Append($"{port.TypeOfPort}     {port.PortState}\n");
                                    }
                                }

                                await client.SendTextMessageAsync(chatId, $"<code>{nmapInfo}</code>", ParseMode.Html);

                                return(true);
                            }
                        }

                        await client.SendTextMessageAsync(chatId, "<code>Неверный IP адрес</code>", ParseMode.Html);

                        return(false);
                    }

                    await client.SendTextMessageAsync(chatId, "<code>Неверные параметры команды</code>", ParseMode.Html);

                    return(false);
                }
            }

            await client.SendTextMessageAsync(chatId, "<code>Пользователя не существует</code>", ParseMode.Html);

            return(false);
        }
Пример #4
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                string[] parameters = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                if (parameters[0] == "cd")
                {
                    var text = message.Text.Remove(0, 2).Trim();

                    LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                    if (linuxSystem != null)
                    {
                        CurrentDirectory currentDirectory = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                        if (currentDirectory != null)
                        {
                            Directory directory  = _unitOfWork.DirectoryRepository.GetInDirectory(await _unitOfWork.DirectoryRepository.GetByIdAsync(currentDirectory.DirectoryId));
                            Directory changedDir = directory.Directories.FirstOrDefault(d => d.Name == text);

                            if (changedDir != null)
                            {
                                user.LinuxSystem.CurrentDirectory.Directory = changedDir;

                                await _unitOfWork.SaveAsync();


                                await client.SendTextMessageAsync(chatId, "<code>Папка изменена</code>", ParseMode.Html);

                                return(true);
                            }
                            else
                            {
                                await client.SendTextMessageAsync(chatId, "<code>Директории не найдено</code>", ParseMode.Html);

                                return(false);
                            }
                        }

                        return(false);
                    }

                    return(false);
                }
            }

            return(false);
        }
Пример #5
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                CurrentDirectory current = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                Directory directory = _unitOfWork.DirectoryRepository.GetInDirectory(await _unitOfWork.DirectoryRepository.GetByIdAsync(current.DirectoryId));

                var searchedDir = directory.Path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).ToList();
                searchedDir.Remove(searchedDir.Last());
                if (searchedDir.Count == 0)
                {
                    await client.SendTextMessageAsync(chatId, "<code>Вы в корне</code>", ParseMode.Html);

                    return(true);
                }

                string dirPath = "";
                foreach (var path in searchedDir)
                {
                    dirPath += path;
                }

                Directory searchedDirectory = await _unitOfWork.DirectoryRepository.GetByPath(dirPath);

                if (searchedDirectory != null)
                {
                    user.LinuxSystem.CurrentDirectory.Directory = searchedDirectory;

                    await _unitOfWork.SaveAsync();

                    await client.SendTextMessageAsync(chatId, "<code>Папка изменена</code>", ParseMode.Html);

                    return(true);
                }

                return(false);
            }

            return(false);
        }
Пример #6
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null)
                {
                    WifiModule wifiModule = await _unitOfWork.WifiModuleRepository.GetByIdAsync(linuxSystem.WifiModuleId);

                    if (wifiModule != null)
                    {
                        StringBuilder lanDetails = new StringBuilder();
                        lanDetails.Append("<code>lo: flags=73 UP,LOOPBACK,RUNNING  mtu 1500\n" +
                                          "inet 127.0.0.1  netmask 255.0.0.0\n" +
                                          "inet6::1  prefixlen 128  scopeid 0xfe  compat, link, site, host \n" +
                                          "loop(Local Loopback) </code>");

                        await client.SendTextMessageAsync(chatId, lanDetails.ToString(), ParseMode.Html);

                        lanDetails.Clear();

                        lanDetails.Append($"<code>{wifiModule.Name}: flags=4163 UP,BROADCAST,RUNNING,MULTICAST  mtu 1500\n" +
                                          $"inet {linuxSystem.IP}  netmask 255.255.255.0  broadcast {linuxSystem.IP}\n" +
                                          "inet6 fe80::bd6d:680a: 8ca8: c15f  prefixlen 64  scopeid 0xfd  compat, link, site, host \n" +
                                          $"ether {linuxSystem.MACAddress}(Ethernet)\n" +
                                          $"Mode: {GetWifiMode(wifiModule.ModuleMode)}</code>");

                        await client.SendTextMessageAsync(chatId, lanDetails.ToString(), ParseMode.Html);

                        return(true);
                    }

                    return(false);
                }

                return(false);
            }

            return(false);
        }
Пример #7
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null)
                {
                    WifiModule wifiModule = await _unitOfWork.WifiModuleRepository.GetByIdAsync(linuxSystem.WifiModuleId);

                    if (wifiModule != null && user.isAuthorized && wifiModule.ModuleMode == ModuleMode.Monitor)
                    {
                        StringBuilder wifis       = new StringBuilder();
                        List <Wifi>   moduleWifis = _unitOfWork.WifiRepository.GetByWifisModuleId(wifiModule.Id).ToList();

                        foreach (var wifi in moduleWifis)
                        {
                            wifis.Append($"BSSID: {wifi.BSSID}    SPEED: {wifi.Speed}мб/с    CH: {wifi.Channel}    CIP: {GetCipher(wifi.Cipher)}    ENC: {GetEncryption(wifi.EncryptionType)}    ESSID: {wifi.Name}\n");
                        }

                        await client.SendTextMessageAsync(chatId, $"<code>{wifis}</code>", ParseMode.Html);

                        return(true);
                    }

                    return(false);
                }

                return(false);
            }

            return(false);
        }
Пример #8
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null)
                {
                    WifiModule wifiModule = await _unitOfWork.WifiModuleRepository.GetByIdAsync(linuxSystem.WifiModuleId);

                    if (wifiModule != null)
                    {
                        if (user.isAuthorized && wifiModule.ModuleMode == ModuleMode.Managed)
                        {
                            wifiModule.ModuleMode = ModuleMode.Monitor;
                            wifiModule.Name       = "wlan0mon";

                            await _unitOfWork.SaveAsync();

                            await client.SendTextMessageAsync(chatId, "<code>Режим изменён</code>", ParseMode.Html);

                            return(true);
                        }
                    }

                    return(false);
                }

                return(false);
            }

            return(false);
        }
Пример #9
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                if (linuxSystem != null && linuxSystem.IsConnectedTheInternet)
                {
                    string[] commandParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    if (commandParams[0] == Name && !string.IsNullOrWhiteSpace(commandParams[1]) &&
                        commandParams[2] == "-P")
                    {
                        File passwordFile = await _unitOfWork.FileRepository.GetByPath(commandParams[3]);

                        if (commandParams.Length == 5)
                        {
                            string[] sshParams = commandParams[4].Split(new string[] { "//" }, StringSplitOptions.RemoveEmptyEntries);
                            if (sshParams.Length == 2)
                            {
                                if (passwordFile != null && sshParams[0] == "ssh:" && !string.IsNullOrWhiteSpace(sshParams[1]))
                                {
                                    LinuxSystem victimSystem = await _unitOfWork.LinuxRepository.GetByIP(sshParams[1]);

                                    if (victimSystem != null)
                                    {
                                        List <Vulnerability> vulnerabilities = _unitOfWork.VulnerabilityRepository.GetVulnerabilitiesByLinuxSystemId(victimSystem.Id);
                                        if (vulnerabilities.Count > 0)
                                        {
                                            foreach (var vuln in vulnerabilities)
                                            {
                                                foreach (var port in vuln.Ports)
                                                {
                                                    await client.SendTextMessageAsync(chatId, "<code>Подбор пароля...</code>", ParseMode.Html);

                                                    if (passwordFile.Text.Contains(port.Password) && commandParams[1] == port.Login)
                                                    {
                                                        await client.SendTextMessageAsync(chatId, $"<code>[22][ssh]  host: {sshParams[1]}   login: {port.Login}   password: {port.Password}</code>", ParseMode.Html);

                                                        return(true);
                                                    }
                                                    else
                                                    {
                                                        await client.SendTextMessageAsync(chatId, "<code>Пароль не найден.</code>", ParseMode.Html);

                                                        return(false);
                                                    }
                                                }
                                            }
                                        }

                                        await client.SendTextMessageAsync(chatId, "<code>В системе нету уязвимостей</code>", ParseMode.Html);

                                        return(false);
                                    }

                                    await client.SendTextMessageAsync(chatId, "<code>Неверный IP адресс.</code>", ParseMode.Html);

                                    return(false);
                                }

                                await client.SendTextMessageAsync(chatId, "<code>Неверный IP адресс.</code>", ParseMode.Html);

                                return(false);
                            }
                        }

                        await client.SendTextMessageAsync(chatId, "<code>Проверьте корректность параметров команды.</code>", ParseMode.Html);

                        return(false);
                    }

                    await client.SendTextMessageAsync(chatId, "<code>Неверная команда.</code>", ParseMode.Html);

                    return(false);
                }

                await client.SendTextMessageAsync(chatId, "<code>Ошибка. Проверьте подключение к интернету.</code>", ParseMode.Html);

                return(false);
            }

            return(false);
        }
Пример #10
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (user != null && user.isAuthorized)
            {
                string[] parameters = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                if (parameters[0] == Name && parameters[2] == "-w")
                {
                    LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                    CurrentDirectory currentDirectory = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                    Directory directory     = _unitOfWork.DirectoryRepository.GetInDirectory(await _unitOfWork.DirectoryRepository.GetByIdAsync(currentDirectory.DirectoryId));
                    string    fileExtension = "";
                    string    fileName      = "";

                    if (!parameters[1].Contains("/"))
                    {
                        fileExtension = parameters[1].Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries)[1];
                        fileName      = parameters[1];
                    }
                    else
                    {
                        string filePath = parameters[1].Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Last();
                        fileExtension = filePath.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries)[1];
                        fileName      = filePath;
                    }


                    File handShakeFile = directory.Files.FirstOrDefault(f => f.Name == parameters[1]);
                    File passwordFile  = null;
                    if (fileExtension == "cap" && handShakeFile != null)
                    {
                        if (parameters[3].Contains("/"))
                        {
                            passwordFile = await _unitOfWork.FileRepository.GetByPath(parameters[3]);
                        }
                        else
                        {
                            passwordFile = directory.Files.FirstOrDefault(f => f.Name == parameters[3]);
                        }

                        if (passwordFile != null)
                        {
                            WifiModule wifiModule = await _unitOfWork.WifiModuleRepository.GetByIdAsync(linuxSystem.WifiModuleId);

                            IEnumerable <Wifi> wifis = _unitOfWork.WifiRepository.GetByWifisModuleId(wifiModule.Id);

                            if (wifis.Count() > 0)
                            {
                                string password = Encoding.UTF8.GetString(Convert.FromBase64String(handShakeFile.Text));
                                if (passwordFile.Text.Contains(password))
                                {
                                    Wifi attackWifi = null;
                                    foreach (var wifi in wifis)
                                    {
                                        await client.SendTextMessageAsync(chatId, $"<code>[{DateTime.UtcNow}] Подбор пароля...</code>", ParseMode.Html);

                                        if (wifi.Password == password)
                                        {
                                            attackWifi = wifi;
                                            break;
                                        }
                                    }

                                    if (attackWifi != null)
                                    {
                                        linuxSystem.IsConnectedTheInternet = true;
                                        GlobalNetwork globalNetwork = await _unitOfWork.GlobalNetworkRepository.GetByIdAsync(attackWifi.GlobalNetworkId);

                                        if (globalNetwork != null)
                                        {
                                            user.GlobalNetwork = globalNetwork;
                                            await client.SendTextMessageAsync(chatId, $"<code>Пароль успешно найден, вы подсойдены к {attackWifi.Name}\nСкорость: {attackWifi.Speed}мб/с</code>", ParseMode.Html);

                                            wifiModule.ModuleMode = ModuleMode.Managed;
                                            wifiModule.Name       = "wlan0";

                                            await _unitOfWork.SaveAsync();

                                            return(true);
                                        }
                                        else
                                        {
                                            await client.SendTextMessageAsync(chatId, $"<code>Ошибка подлючения...</code>", ParseMode.Html);

                                            return(false);
                                        }
                                    }
                                }

                                await client.SendTextMessageAsync(chatId, "<code>Пароль не найдено</code>", ParseMode.Html);
                            }

                            return(false);
                        }

                        await client.SendTextMessageAsync(chatId, "<code>Файл с паролями не найден. Перейдите в папку с этим файлом или укажите путь.</code>", ParseMode.Html);

                        return(false);
                    }
                    else
                    {
                        await client.SendTextMessageAsync(chatId, "<code>Файл не найден. Перейдите в папку с этим файлом или укажите путь..</code>", ParseMode.Html);

                        return(false);
                    }
                }
                else
                {
                    await client.SendTextMessageAsync(chatId, "<code>Неверная команда</code>", ParseMode.Html);

                    return(false);
                }
            }

            return(false);
        }
Пример #11
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            User user = await _unitOfWork.UserAccessRepository.GetUserByChatId(message.Chat.Id);

            if (user.isAuthorized)
            {
                StringBuilder dirs        = new StringBuilder();
                LinuxSystem   linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

                CurrentDirectory currentDirectory = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                Directory directory = _unitOfWork.DirectoryRepository.GetInDirectory
                                          (await _unitOfWork.DirectoryRepository.GetByIdAsync(currentDirectory.DirectoryId));

                IEnumerable <Directory> directories = directory.Directories;
                IEnumerable <File>      files       = directory.Files;

                if (directories.Count() == 0 &&
                    files.Count() == 0)
                {
                    dirs.Append("<code>Папка пустая</code>");
                    await client.SendTextMessageAsync(message.Chat.Id, dirs.ToString(), ParseMode.Html);

                    return(true);
                }
                if (message.Text == Name)
                {
                    foreach (var dir in directories)
                    {
                        dirs.Append($"<code>{dir.Name}</code>\n");
                    }

                    foreach (var file in files)
                    {
                        dirs.Append($"<code>{file.Name}</code>\n");
                    }

                    await client.SendTextMessageAsync(message.Chat.Id, dirs.ToString(), ParseMode.Html);

                    return(true);
                }
                else
                {
                    string[] showDirsParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    if (showDirsParams[0] == Name && showDirsParams[1] == "-la")
                    {
                        List <int> ids = directories.Select(d => d.Id).ToList();
                        Dictionary <int, List <File> > dirFiles = _unitOfWork.FileRepository.GetFilesOfSomeDirs(ids);
                        foreach (var dir in directories)
                        {
                            dirs.Append($"<code>{dir.GetSizeOfDir(dirFiles[dir.Id])}\t{dir.TimeOfCreating.ToString("MMM", CultureInfo.InvariantCulture)}\t{dir.TimeOfCreating.Day}\t{dir.Name}</code>\n");
                        }
                        foreach (var file in files)
                        {
                            dirs.Append($"<code>{file.Size}\t{file.TimeOfCreating.ToString("MMM", CultureInfo.InvariantCulture)}\t{file.TimeOfCreating.Day}\t{file.Name}</code>\n");
                        }

                        await client.SendTextMessageAsync(message.Chat.Id, dirs.ToString(), ParseMode.Html);

                        return(true);
                    }

                    return(false);
                }
            }

            return(false);
        }
Пример #12
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

            WifiModule wifiModule = await _unitOfWork.WifiModuleRepository.GetByIdAsync(linuxSystem.WifiModuleId);

            if (user != null && user.isAuthorized && wifiModule.ModuleMode == ModuleMode.Monitor)
            {
                string[]           commandParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                IEnumerable <Wifi> wifis         = _unitOfWork.WifiRepository.GetByWifisModuleId(wifiModule.Id);
                bool isExist = wifis.Any(w => w.BSSID == commandParams[4]);

                if (commandParams[1] == "--deauth" && commandParams[3] == "-a" &&
                    isExist && commandParams[5] == wifiModule.Name)
                {
                    for (int i = 0; i < 8; i++)
                    {
                        await client.SendTextMessageAsync(chatId, $"<code>{DateTime.UtcNow.ToString("HH:mm:ss")}  Sending DeAuth to broadcast -- BSSID: [{commandParams[4]}]</code>", ParseMode.Html);

                        Thread.Sleep(1000);
                    }

                    user.CountOfCrackWifi++;
                    await _unitOfWork.SaveAsync();

                    Wifi wifi = wifis.FirstOrDefault(w => w.BSSID == commandParams[4]);

                    if (wifi != null)
                    {
                        CurrentDirectory currentDirectory = await _unitOfWork.CurrentDirectoryRepository.GetByIdAsync(linuxSystem.CurrentDirectoryId);

                        if (currentDirectory != null)
                        {
                            Directory directory = _unitOfWork.DirectoryRepository.GetInDirectory
                                                      (await _unitOfWork.DirectoryRepository.GetByIdAsync(currentDirectory.DirectoryId));
                            List <File> curDirFiles = directory.Files.ToList();

                            File file = new File()
                            {
                                Name           = $"Wifi-Crack{user.CountOfCrackWifi}.cap",
                                Size           = new Random().Next(100, 500),
                                TimeOfCreating = DateTime.UtcNow,
                                Text           = Convert.ToBase64String(Encoding.UTF8.GetBytes(wifi.Password))
                            };

                            directory.Files.Add(file);

                            await _unitOfWork.SaveAsync();

                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }

                    return(false);
                }
                else
                {
                    await client.SendTextMessageAsync(chatId, "<code>Неверные данные</code>", ParseMode.Html);

                    return(false);
                }
            }

            return(false);
        }
Пример #13
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;

            //IP of linux system
            string IP = GetRandIP();

            //Directories of user who want to register
            List <Directory> realUserDirs = GetDirectories();

            foreach (var dir in realUserDirs)
            {
                string currentPath = IP + dir.Path;
                dir.Path = currentPath;
            }

            //Adding folder with password list to wifi
            realUserDirs.Add(
                new Directory()
            {
                Name           = "Files",
                Path           = $"{IP}@root/Files",
                TimeOfCreating = DateTime.UtcNow,
                Files          = new List <File>()
                {
                    new File()
                    {
                        Name           = "wifiPasswords.txt",
                        Path           = $"{IP}@root/Files/wifiPasswords.txt",
                        TimeOfCreating = DateTime.UtcNow,
                        Size           = new Random().Next(60, 700),
                        Text           = GetPasswordValues().passwords
                    },
                    new File()
                    {
                        Name           = "sshPass.txt",
                        Path           = $"{IP}@root/Files/sshPass.txt",
                        TimeOfCreating = DateTime.UtcNow,
                        Size           = new Random().Next(60, 700),
                        Text           = GetSshPasswordData().allPasswordsSsh
                    }
                }
            });

            //Wifis which will be dispayed to user
            ICollection <Wifi> wifis = GetWifis();

            //Creating user which pressed the start button
            User user = new User()
            {
                ChatId              = chatId,
                FirstName           = message.From.FirstName,
                UserName            = message.From.Username,
                LastName            = message.From.LastName,
                HaveLinuxPermission = false,
                LinuxSystem         = new LinuxSystem()
                {
                    IsConnectedTheInternet = false,
                    WifiModule             = new WifiModule()
                    {
                        ModuleMode = ModuleMode.Managed,
                        Name       = "wlan0",
                        Wifis      = wifis
                    },
                    AllDirectories   = realUserDirs,
                    CurrentDirectory = new CurrentDirectory()
                    {
                        Directory = new Directory()
                        {
                            Directories    = realUserDirs,
                            Files          = new List <File>(),
                            TimeOfCreating = DateTime.UtcNow,
                            Path           = $"{IP}@root",
                            Name           = $"{IP}@root"
                        }
                    },
                    MACAddress      = GetRandomBSSID(),
                    IP              = IP,
                    Vulnerabilities = new List <Vulnerability>()
                    {
                        new Vulnerability()
                        {
                            Ports = new List <Port>()
                            {
                                new Port()
                                {
                                    Login      = Guid.NewGuid().ToString(),
                                    Password   = Guid.NewGuid().ToString(),
                                    PortState  = PortState.Close,
                                    TypeOfPort = TypeOfPort.SSH
                                }
                            }
                        }
                    }
                },
                CountOfCrackWifi = 0,
                GlobalNetwork    = new GlobalNetwork()
            };

            //Creating list of user's which will be hacked by real user
            List <User> victims = new List <User>();

            for (int i = 0; i < 4; i++)
            {
                victims.Add(GetVictimUser());
            }

            int counter = 0;

            foreach (var victim in victims)
            {
                victim.LinuxSystem.WifiModule.Wifis = wifis;
                victim.GlobalNetwork = wifis.ToList()[counter].GlobalNetwork;
                counter++;
            }

            //Checking if user is exist in the database
            User tempUser = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            if (tempUser == null)
            {
                await _unitOfWork.UserAccessRepository.AddAsync(user);

                await _unitOfWork.UserAccessRepository.AddRange(victims);

                await client.SendTextMessageAsync(chatId, "<code>Спасибо за регистрацию! Теперь мы можем начать ✅</code>", ParseMode.Html);

                await client.SendTextMessageAsync(chatId, "<code>Процесс подготовки...</code>", ParseMode.Html);

                await client.SendTextMessageAsync(chatId, "<code>Ещё немного...</code>", ParseMode.Html);

                await client.SendTextMessageAsync(chatId, "<code>Введите логин и пароль в формате login:password 🌐</code>", ParseMode.Html);

                return(true);
            }

            await client.SendTextMessageAsync(chatId, "<code>Вы уже зарегестрированы! ✅</code>", ParseMode.Html);

            return(false);
        }
Пример #14
0
        /// <summary>
        /// Getting victim users which will be hacked by real user
        /// </summary>
        private User GetVictimUser()
        {
            List <Directory> artificialUserDirs = GetDirectories();
            string           IP = GetRandIP();

            foreach (var dir in artificialUserDirs)
            {
                string currentPath = IP + dir.Path;
                dir.Path = currentPath;
            }

            string name = Guid.NewGuid().ToString();

            User victimSystem = new User()
            {
                ChatId              = 1,
                FirstName           = Guid.NewGuid().ToString(),
                UserName            = name,
                LastName            = Guid.NewGuid().ToString(),
                HaveLinuxPermission = true,
                LinuxSystem         = new LinuxSystem()
                {
                    IsConnectedTheInternet = true,
                    WifiModule             = new WifiModule()
                    {
                        ModuleMode = ModuleMode.Managed,
                        Name       = "wlan0"
                    },
                    AllDirectories   = artificialUserDirs,
                    CurrentDirectory = new CurrentDirectory()
                    {
                        Directory = new Directory()
                        {
                            Directories    = artificialUserDirs,
                            Files          = new List <File>(),
                            TimeOfCreating = DateTime.UtcNow,
                            Path           = $"{IP}@root",
                            Name           = $"{IP}@root"
                        }
                    },
                    MACAddress      = GetRandomBSSID(),
                    IP              = IP,
                    Vulnerabilities = new List <Vulnerability>()
                    {
                        new Vulnerability()
                        {
                            Ports = new List <Port>()
                            {
                                new Port()
                                {
                                    Login      = name,
                                    Password   = GetSshPasswordData().passwordSsh,
                                    PortState  = PortState.Open,
                                    TypeOfPort = TypeOfPort.SSH
                                }
                            }
                        }
                    }
                }
            };

            return(victimSystem);
        }
Пример #15
0
        public async Task <bool> Execute(Message message, TelegramBotClient client)
        {
            long chatId = message.Chat.Id;
            User user   = await _unitOfWork.UserAccessRepository.GetUserByChatId(chatId);

            LinuxSystem linuxSystem = await _unitOfWork.LinuxRepository.GetByIdAsync(user.Id);

            if (user != null && linuxSystem != null && user.isAuthorized && linuxSystem.IsConnectedTheInternet)
            {
                string[] commandParams = message.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                if (commandParams.Length == 3 && commandParams[0] == Name)
                {
                    string[] connectParams = commandParams[1].Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries);
                    if (connectParams.Length == 2)
                    {
                        LinuxSystem victimSystem = await _unitOfWork.LinuxRepository.GetByIP(connectParams[0]);

                        if (victimSystem != null)
                        {
                            List <Vulnerability> vulnerabilities = _unitOfWork.VulnerabilityRepository.GetVulnerabilitiesByLinuxSystemId(victimSystem.Id);
                            if (vulnerabilities.Count > 0)
                            {
                                foreach (var vuln in vulnerabilities)
                                {
                                    foreach (var port in vuln.Ports)
                                    {
                                        if (port.Password == commandParams[2] && port.Login == connectParams[1])
                                        {
                                            await client.SendTextMessageAsync(chatId, $"<code>Вы подлючены к {victimSystem.IP}\nПоздравляем!Вы пройшли игру, подключение к чужому ПК - это был флаг\nУспехов вам в жизни!</code>", ParseMode.Html);

                                            return(true);
                                        }
                                    }
                                }

                                await client.SendTextMessageAsync(chatId, "<code>Порты либо закрыты, либо неверный пароль.</code>", ParseMode.Html);

                                return(false);
                            }

                            await client.SendTextMessageAsync(chatId, "<code>Все порты закрыты.</code>", ParseMode.Html);

                            return(false);
                        }

                        await client.SendTextMessageAsync(chatId, "<code>Системы по такому адресу не существует.</code>", ParseMode.Html);

                        return(false);
                    }

                    await client.SendTextMessageAsync(chatId, "<code>Неверные параметры команды.</code>", ParseMode.Html);

                    return(false);
                }

                await client.SendTextMessageAsync(chatId, "<code>Неверные параметры команды.</code>", ParseMode.Html);

                return(false);
            }

            return(false);
        }