Пример #1
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            // Удаляем из базы старые IP адреса
            if (!memoryCache.TryGetValue("Cron-WhitePtrIP_ClearIP", out byte _))
            {
                memoryCache.Set("Cron-WhitePtrIP_ClearIP", (byte)1, TimeSpan.FromHours(1));

                SqlToMode.SetMode(SqlMode.Read);
                foreach (var whiteIP in coreDB.WhitePtrIPs.AsNoTracking())
                {
                    if (DateTime.Now > whiteIP.Expires)
                    {
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.WhitePtrIPs), whiteIP.Id));
                    }
                }
                SqlToMode.SetMode(SqlMode.ReadOrWrite);

                // Раз в час
                GC.Collect(GC.MaxGeneration);
            }

            IsRun = false;
        }
Пример #2
0
        public static void UpdateCacheToUserAgent()
        {
            string oldUserAgentRegex = UserAgentRegex;

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.Read);

            // Подключаемся к базе
            using (CoreDB coreDB = Service.Get <CoreDB>())
            {
                List <string> mass = new List <string>();
                foreach (var blockedIP in coreDB.BlockedsIP.AsNoTracking())
                {
                    if (blockedIP.BlockingTime > DateTime.Now && blockedIP.typeBlockIP == TypeBlockIP.UserAgent)
                    {
                        mass.Add(blockedIP.IP);
                        Trigger.OnAddUserAgent((blockedIP.IP, blockedIP.Description, blockedIP.BlockingTime));
                    }
                }

                // Клеим данные в строчку
                UserAgentRegex = mass.Count == 0 ? "^$" : $"({string.Join("|", mass)})";
            }

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.ReadOrWrite);
            Trigger.OnUpdateCacheToUserAgent((oldUserAgentRegex, UserAgentRegex));
        }
Пример #3
0
        public static void Cron(object ob)
        {
            try
            {
                using (CoreDB coreDB = Service.Get <CoreDB>())
                {
                    JsonDB jsonDB      = Service.Get <JsonDB>();
                    var    memoryCache = Service.Get <IMemoryCache>();

                    Engine.Cron.Project.Run(coreDB, jsonDB, memoryCache);           // Получение новостей и списка изменений
                    Engine.Cron.UpdateAV.Run(coreDB, jsonDB, memoryCache);          // Обновление антивируса

                    Engine.Cron.BlockedIP.Run(coreDB, memoryCache);                 // Удаляем из базы старые IP адреса
                    Engine.Cron.WhitePtrIP.Run(coreDB, memoryCache);                // Удаляем из базы старые IP адреса
                    Engine.RequestsFilter.Access.AccessIP.Clear();                  // Очистка списка IP с разрешенным доступом
                    Engine.Cron.Home.Run(coreDB, memoryCache);                      // Очистка журнала посещений
                    Engine.Cron.Auth.Run(coreDB, memoryCache);                      // Очистка сессий
                    Engine.Cron.AntiDdos.Run(coreDB, jsonDB, memoryCache);          // Сбор статистики && очистка базы и правил IPTables
                    Engine.Cron.AntiDdos.Run(coreDB, jsonDB, memoryCache);          // Сбор статистики && очистка базы и правил IPTables

                    Engine.Cron.Monitoring.Run(coreDB, memoryCache);                // Статистика "/isp/monitoring"
                    Engine.Base.SqlAndCache.WriteLogTo.CloseFiles();                // Закрытие потоков на файлах которые не используются
                    Engine.Base.SqlAndCache.WriteLogTo.ZipFiles();                  // Сжатие логов

                    Engine.Cron.Notifications.Run(coreDB, jsonDB, memoryCache);     // Уведомления
                    Engine.Cron.AntiVirus.Run(coreDB);                              // Проверка доменов антивирусом
                    Engine.Cron.SyncBackup.Run(coreDB, memoryCache);                // SyncBackup
                }
            }
            catch (Exception ex)
            {
                File.AppendAllText(Folders.File.SystemErrorLog, ex.ToString() + "\n\n=======================================================================\n\n");
            }
        }
Пример #4
0
        public static bool CheckUserAgent(string userAgent)
        {
            if (userAgentsRegex != null)
            {
                return(Regex.IsMatch(userAgent, userAgentsRegex, RegexOptions.IgnoreCase));
            }

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.Read);

            // Подключаемся к базе
            using (CoreDB coreDB = Service.Get <CoreDB>())
            {
                List <string> mass = new List <string>();
                foreach (var blockedIP in coreDB.BlockedsIP.AsNoTracking())
                {
                    if (blockedIP.BlockingTime > DateTime.Now && blockedIP.typeBlockIP == TypeBlockIP.UserAgent)
                    {
                        mass.Add(blockedIP.IP);
                    }
                }

                // Клеим данные в строчку
                userAgentsRegex = mass.Count == 0 ? "^$" : $"({string.Join("|", mass)})";
            }

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.ReadOrWrite);

            // Результат
            return(Regex.IsMatch(userAgent, userAgentsRegex, RegexOptions.IgnoreCase));
        }
Пример #5
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            // Очистка сессий
            if (!memoryCache.TryGetValue("Cron-Auth_Session", out _))
            {
                memoryCache.Set("Cron-Auth_Session", (byte)1, TimeSpan.FromHours(3));

                SqlToMode.SetMode(SqlMode.Read);
                foreach (var session in coreDB.Auth_Sessions.AsNoTracking())
                {
                    // Удаляем старые записи
                    if (DateTime.Now > session.Expires)
                    {
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.Auth_Sessions), session.Id));
                    }
                }
                SqlToMode.SetMode(SqlMode.ReadOrWrite);
            }

            IsRun = false;
        }
Пример #6
0
 public Time(CoreDB db, IProduct productRepository, ICampaign campaignRepository, IOrder orderRepository)
 {
     _campaignRepository = campaignRepository;
     _orderRepository    = orderRepository;
     _productRepository  = productRepository;
     _db = db;
 }
Пример #7
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            // Очистка журнала посещений
            if (!memoryCache.TryGetValue("Cron-Home_Jurnals", out _))
            {
                memoryCache.Set("Cron-Home_Jurnals", (byte)1, TimeSpan.FromHours(12));

                SqlToMode.SetMode(SqlMode.Read);
                var expires = DateTime.Now.AddDays(-90);

                // Пропускаем последние 60 записей
                foreach (var jurn in coreDB.Home_Jurnals.AsNoTracking().AsEnumerable().Reverse().Skip(60))
                {
                    // Удаляем старые записи
                    if (expires > jurn.Time)
                    {
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.Home_Jurnals), jurn.Id));
                    }
                }
                SqlToMode.SetMode(SqlMode.ReadOrWrite);

                // Раз в 12 часов
                GC.Collect(GC.MaxGeneration);
            }

            IsRun = false;
        }
Пример #8
0
        public Table loadTable(string tableName)
        {
            Table table = new Table(IO.LoadXMLTable(tableName, CoreDB.getPath()), tableName);

            Tables.Add(table);
            return(table);
        }
Пример #9
0
 internal void addTableNameToList(string tableName)
 {
     IncreaseHead();
     xTable.Root.Add(new XElement("Table", tableName));
     Names.Add(tableName);
     new TableIO().Save("table_list", CoreDB.getPath(), xTable);
 }
Пример #10
0
        public static void Run(CoreDB coreDB, JsonDB jsonDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            // Очистка сессий
            if (!memoryCache.TryGetValue("Cron-Auth_Session", out _))
            {
                memoryCache.Set("Cron-Auth_Session", (byte)1, TimeSpan.FromMinutes(30));

                SqlToMode.SetMode(SqlMode.Read);
                foreach (var session in coreDB.Auth_Sessions.AsNoTracking())
                {
                    // Удаляем старые записи
                    // Если включена авторизация 2FA и сессии больше 20 минут
                    if (DateTime.Now > session.Expires || (jsonDB.Base.EnableTo2FA && !session.Confirm2FA && DateTime.Now.AddMinutes(-20) > session.CreateTime))
                    {
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.Auth_Sessions), session.Id));
                    }
                }
                SqlToMode.SetMode(SqlMode.ReadOrWrite);
            }

            IsRun = false;
        }
Пример #11
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="navPage">Навигация</param>
 /// <param name="ajax">ajax запрос</param>
 /// <param name="jsonDB">База Json</param>
 /// <param name="coreDB">База SQL</param>
 /// <param name="memoryCache">Кеш</param>
 public PageToView(NavPage <T> navPage, bool ajax, JsonDB jsonDB, CoreDB coreDB, IMemoryCache memoryCache)
 {
     this.Page        = navPage;
     this.ajax        = ajax;
     this.jsonDB      = jsonDB;
     this.coreDB      = coreDB;
     this.memoryCache = memoryCache;
 }
        public override IHttpActionResult Patch(Guid id, [FromBody] JObject model)
        {
            using (CoreDB db = new CoreDB(UserK))
            {
                db.SaveChanges();
            }

            return(Ok());
        }
Пример #13
0
 internal void removeReferencePrefix(string tableName)
 {
     try
     {
         xTable.Root.Elements().First(element => element.Value == tableName).Attribute("FOREIGN_KEY").Remove();
         new TableIO().Save("table_list", CoreDB.getPath(), xTable);
     }
     catch { }
 }
Пример #14
0
 public Table(XDocument xdoc, string tableName)
 {
     Columns         = new List <Column>();
     this._xDocument = xdoc;
     path            = CoreDB.getPath();
     this.tableName  = tableName;
     entity          = new Entity(_xDocument.Root.Element("Entity"));
     InitializeColumns();
     InitializeLines();
     InitializeColumnLine();
 }
Пример #15
0
        /// <summary>
        /// Удалить запись
        /// </summary>
        /// <typeparam name="T">Тип данных</typeparam>
        /// <param name="db">Таблица</param>
        /// <param name="coreDB">База</param>
        /// <param name="Id">Id записи</param>
        public static bool RemoveAttach <T>(this DbSet <T> db, CoreDB coreDB, int Id) where T : class, IId, new()
        {
            try
            {
                // Получаем данные
                var item = new T()
                {
                    Id = Id
                };
                db.Attach(item);

                // Удаляем данные
                db.Remove(item);

                // Сохраняем базу
                coreDB.SaveChanges();

                // Отдаем результат
                return(true);
            }
            catch { return(false); }
        }
Пример #16
0
        public static void Run(CoreDB coreDB, JsonDB jsonDB, IMemoryCache memoryCache)
        {
            // Очистка базы от старых уведомлений
            if (memoryCache.TryGetValue("CronNoteClearDB", out DateTime CronDate))
            {
                // Если дата отличается от текущей
                if (CronDate.Day != DateTime.Now.Day)
                {
                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.Read);

                    // Создаем кеш
                    memoryCache.Set("CronNoteClearDB", DateTime.Now);

                    // Удаляем  записи старше 180 дней
                    foreach (var item in coreDB.Notations.AsNoTracking())
                    {
                        if (DateTime.Now > item.Time.AddDays(180))
                        {
                            // Удаляем заметку
                            coreDB.Notations.RemoveAttach(coreDB, item.Id);
                        }
                    }

                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);

                    // Раз в день
                    GC.Collect(GC.MaxGeneration);
                }
            }
            else
            {
                // Создаем кеш задним числом
                memoryCache.Set("CronNoteClearDB", DateTime.Now.AddDays(-1));
            }
        }
Пример #17
0
 public Product(CoreDB db)
 {
     _db = db;
 }
Пример #18
0
 internal void addReferencePrefix(string tableName)
 {
     xTable.Root.Elements().First(element => element.Value == tableName).Add(new XAttribute("FOREIGN_KEY", ""));
     new TableIO().Save("table_list", CoreDB.getPath(), xTable);
 }
Пример #19
0
 public Order(CoreDB db, IProduct productRepository)
 {
     _db = db;
     _productRepository = productRepository;
 }
Пример #20
0
        public static void Run(CoreDB coreDB, JsonDB jsonDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            if (!memoryCache.TryGetValue("Cron-ProjectInfo", out _))
            {
                memoryCache.Set("Cron-ProjectInfo", (byte)0, Startup.AbsoluteExpirationToAPI);

                #region Получаем новости проекта
                try
                {
                    HttpClient client  = new HttpClient();
                    var        newsAPI = JsonConvert.DeserializeObject <List <ProjectNews> >(client.GetStringAsync("http://api.core-system.org/isp/news").Result);
                    if (newsAPI.Count > 0)
                    {
                        jsonDB.ProjectNews = newsAPI;
                        jsonDB.Save();
                    }
                }
                catch { }
                #endregion

                #region Получаем список изменений проекта
                try
                {
                    HttpClient client        = new HttpClient();
                    var        ProjectChange = JsonConvert.DeserializeObject <List <ProjectChange> >(client.GetStringAsync("http://api.core-system.org/isp/change").Result);
                    if (ProjectChange.Count > 0)
                    {
                        jsonDB.ProjectChange = ProjectChange;
                        jsonDB.Save();
                    }
                }
                catch { }
                #endregion

                #region Сравниваем версию ISPCore
                try
                {
                    HttpClient client = new HttpClient();
                    var        result = JsonConvert.DeserializeObject <LatestVersion>(client.GetStringAsync("http://api.core-system.org/isp/LatestVersion").Result);

                    // Сверяем версии ISPCore
                    if (result.Version > 0 && (result.Version > Startup.version.Version || (result.Version == Startup.version.Version && result.Patch > Startup.version.Patch)))
                    {
                        #region Автоматическое обновление ISPCore
                        if (jsonDB.Base.AutoUpdate && (Platform.Get == PlatformOS.Docker || Platform.Get == PlatformOS.Unix))
                        {
                            // Если метод auto-update.sh еще не вызывался для этой версии ISPCore
                            if (!File.Exists($"{Folders.AutoUpdate}/{Startup.version.ToString()}.ok"))
                            {
                                // Проверяем можно ли текущею версию обновлять
                                if (client.GetStringAsync($"http://api.core-system.org/isp/UpdateSupport?Version={Startup.version.Version}&Patch={Startup.version.Patch}&os={PlatformOS.Unix.ToString()}").Result == "ok")
                                {
                                    // Записываем версию ISPCore с которой был вызван auto-update.sh
                                    File.WriteAllText($"{Folders.AutoUpdate}/{Startup.version.ToString()}.ok", string.Empty);

                                    // Обновляем
                                    Bash   bash = new Bash();
                                    string os   = Platform.Get == PlatformOS.Docker ? "docker" : "linux";
                                    bash.Run($"curl -fsSL http://cdn.core-system.org/isp/{os}/auto-update.sh | sh");
                                    return;
                                }
                            }
                        }
                        #endregion

                        // Уведомление
                        var note = new Notation()
                        {
                            Category = "Система",
                            Msg      = jsonDB.Base.AutoUpdate ? "Доступна новая версия ISPCore, требуется ручное обновление" : "Доступна новая версия ISPCore",
                            Time     = DateTime.Now,
                            More     = new List <More>()
                            {
                                new More("Текущая версия", Startup.version.ToString()),
                                new More("Доступна версия", result.ToString())
                            }
                        };

                        // HashData
                        note.HashData = Notation.CreateHashData(note);

                        // Если в базе нету HashData
                        if (coreDB.Notations.AsNoTracking().FirstOrDefault(it => it.HashData == note.HashData) == null)
                        {
                            // Добовляем в базу
                            coreDB.Notations.Add(note);

                            // Сохраняем базу
                            coreDB.SaveChanges();

                            // Обновляем CountNotification
                            jsonDB.Base.CountNotification++;
                            jsonDB.Save();
                        }
                    }
                }
                catch { }
                #endregion
            }

            IsRun = false;
        }
Пример #21
0
        public static void ISPCore()
        {
            using (CoreDB coreDB = Service.Get <CoreDB>())
            {
                // Версия базы
                if (coreDB.Version.AsNoTracking().LastOrDefault() is LatestVersion vSql)
                {
                    // Версия базы совпадает
                    if (vSql.ToString() == Startup.vSql.ToString())
                    {
                        return;
                    }


                    #region Миграция SQL
                    switch (vSql.Version)
                    {
                        #region Первая версия базы
                    case 1.9:
                    {
                        coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_Aliases] ADD [Folder] TEXT NULL ;");
                        vSql.Patch = 1;
                        goto case 0.0;
                    }
                        #endregion

                        #region case 0.0
                    case 0.0:
                    {
                        switch (vSql.Patch)
                        {
                        case 1:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_ConfToLog] ADD [Jurn200] BIGINT DEFAULT 0 NOT NULL ;");
                            goto case 2;
                        }

                            #region case 2
                        case 2:
                        {
                            #region Журнал 200
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_Jurnals200] (
  [Id] INTEGER  NOT NULL
, [City] text NULL
, [Country] text NULL
, [FormData] text NULL
, [Host] text NULL
, [IP] text NULL
, [Method] text NULL
, [Referer] text NULL
, [Region] text NULL
, [Time] text NOT NULL
, [Uri] text NULL
, [UserAgent] text NULL
, [typeJurn] bigint  NOT NULL
, CONSTRAINT [sqlite_master_PK_RequestsFilter_Jurnals200] PRIMARY KEY ([Id])
);");
                            #endregion

                            // Удаляем старые базы
                            coreDB.Database.ExecuteSqlCommand("DROP TABLE [RequestsFilter_NumberOfRequestDay];");
                            coreDB.Database.ExecuteSqlCommand("DROP TABLE [RequestsFilter_NumberOfRequestMonth];");

                            #region Статистика запросов - сутки
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_NumberOfRequestDay] (
  [Id] INTEGER  NOT NULL
, [Count200] bigint  NOT NULL
, [Count2FA] bigint  NOT NULL
, [Count303] bigint  NOT NULL
, [Count401] bigint  NOT NULL
, [Count403] bigint  NOT NULL
, [Count500] bigint  NOT NULL
, [Host] text NULL
, [Time] text NOT NULL
, CONSTRAINT [sqlite_master_PK_RequestsFilter_NumberOfRequestDay] PRIMARY KEY ([Id])
);");
                            #endregion

                            #region Статистика запросов - месяц
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_NumberOfRequestMonth] (
  [Id] INTEGER  NOT NULL
, [Count200] bigint  NOT NULL
, [Count2FA] bigint  NOT NULL
, [Count303] bigint  NOT NULL
, [Count401] bigint  NOT NULL
, [Count403] bigint  NOT NULL
, [Count500] bigint  NOT NULL
, [Time] text NOT NULL
, [allRequests] bigint  NOT NULL
, CONSTRAINT [sqlite_master_PK_RequestsFilter_NumberOfRequestMonth] PRIMARY KEY ([Id])
);");
                            #endregion

                            // Успех
                            goto case 3;
                        }
                            #endregion

                            #region case 3
                        case 3:
                        {
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [WhitePtrIPs] (
  [Id] INTEGER  NOT NULL
, [Expires] text NOT NULL
, [IPv4Or6] text NULL
, CONSTRAINT [sqlite_master_PK_WhitePtrIPs] PRIMARY KEY ([Id])
);");
                            goto case 4;
                        }
                            #endregion

                        case 4:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_LimitRequest] ADD [UseGlobalConf] BIGINT DEFAULT 0 NOT NULL ;");
                            goto case 5;
                        }

                        case 5:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domains] ADD [Auth2faToAccess] BIGINT DEFAULT 0 NOT NULL ;");
                            goto case 6;
                        }

                            #region case 6
                        case 6:
                        {
                            #region Новая таблица AntiBot
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_Domain_AntiBot] (
                                                      [Id] INTEGER  NOT NULL
                                                    , [AddCodeToHtml] text NULL
                                                    , [DomainId] bigint  NOT NULL
                                                    , [UseGlobalConf] bigint  NOT NULL
                                                    , [FirstSkipToBot] bigint  NOT NULL
                                                    , [HourCacheToBot] bigint  NOT NULL
                                                    , [HourCacheToUser] bigint  NOT NULL
                                                    , [RewriteToOriginalDomain] bigint  NOT NULL
                                                    , [WaitUser] bigint  NOT NULL
                                                    , [type] bigint  NOT NULL
                                                    , CONSTRAINT [sqlite_master_PK_RequestsFilter_Domain_AntiBot] PRIMARY KEY ([Id])
                                                    , FOREIGN KEY ([DomainId]) REFERENCES [RequestsFilter_Domains] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                    );
                                                    CREATE UNIQUE INDEX [IX_RequestsFilter_Domain_AntiBot_DomainId] ON [RequestsFilter_Domain_AntiBot] ([DomainId] ASC);
                                                ");
                            #endregion

                            #region Удаляем поле AntiBot в таблице RequestsFilter_Domain
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [table_temp_05032018] (
                                                      [Id] INTEGER  NOT NULL
                                                    , [Protect] bigint  NOT NULL
                                                    , [StopBruteForce] bigint  NOT NULL
                                                    , [host] text NULL
                                                    , [typeBlockIP] bigint  NOT NULL
                                                    , [Auth2faToAccess] bigint DEFAULT 0  NOT NULL
                                                    , CONSTRAINT [sqlite_master_PK_RequestsFilter_Domains] PRIMARY KEY ([Id])
                                                    );

                                                    INSERT INTO [table_temp_05032018] SELECT [id], [Protect], [StopBruteForce], [host], [typeBlockIP], [Auth2faToAccess] FROM [RequestsFilter_Domains];
                                                    ALTER TABLE [RequestsFilter_Domains] RENAME TO [migrate_05032018];
                                                    ALTER TABLE [table_temp_05032018] RENAME TO [RequestsFilter_Domains];
                                                ");
                            #endregion

                            #region Делаем привязку к таблице AntiBot
                            int ColumnId = 1;
                            foreach (var domain in coreDB.RequestsFilter_Domains.AsNoTracking())
                            {
                                coreDB.Database.ExecuteSqlCommand($@"INSERT INTO [RequestsFilter_Domain_AntiBot]
                                                        ([Id]
                                                        ,[AddCodeToHtml]
                                                        ,[DomainId]
                                                        ,[UseGlobalConf]
                                                        ,[FirstSkipToBot]
                                                        ,[HourCacheToBot]
                                                        ,[HourCacheToUser]
                                                        ,[RewriteToOriginalDomain]
                                                        ,[WaitUser]
                                                        ,[type]) 
                                                        VALUES ({ColumnId},null,{domain.Id},0,1,216,12,1,2800,0);
                                                    ");

                                ColumnId++;
                            }
                            #endregion

                            goto case 7;
                        }
                            #endregion

                            #region case 7
                        case 7:
                        {
                            coreDB.Database.ExecuteSqlCommand("UPDATE SQLITE_SEQUENCE SET SEQ=200 WHERE NAME='RequestsFilter_Domains';");
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_Domain_RuleReplaces] (
                                                      [Id] INTEGER  NOT NULL
                                                    , [ContentType] text NULL
                                                    , [DomainId] bigint  NOT NULL
                                                    , [GetArgs] text NULL
                                                    , [IsActive] bigint  NOT NULL
                                                    , [PostArgs] text NULL
                                                    , [RegexWhite] text NULL
                                                    , [ResponceUri] text NULL
                                                    , [TypeResponse] bigint  NOT NULL
                                                    , [kode] text NULL
                                                    , [uri] text NULL
                                                    , CONSTRAINT [sqlite_master_PK_RequestsFilter_Domain_RuleReplaces] PRIMARY KEY ([Id])
                                                    , FOREIGN KEY ([DomainId]) REFERENCES [RequestsFilter_Domains] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                    );
                                                    CREATE INDEX [IX_RequestsFilter_Domain_RuleReplaces_DomainId] ON [RequestsFilter_Domain_RuleReplaces] ([DomainId] ASC);
                                                ");
                            goto case 8;
                        }
                            #endregion

                            #region case 8
                        case 8:
                        {
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_Template_RuleReplaces] (
                                                  [Id] INTEGER  NOT NULL
                                                , [ContentType] text NULL
                                                , [GetArgs] text NULL
                                                , [IsActive] bigint  NOT NULL
                                                , [PostArgs] text NULL
                                                , [RegexWhite] text NULL
                                                , [ResponceUri] text NULL
                                                , [TemplateId] bigint  NOT NULL
                                                , [TypeResponse] bigint  NOT NULL
                                                , [kode] text NULL
                                                , [uri] text NULL
                                                , CONSTRAINT [sqlite_master_PK_RequestsFilter_Template_RuleReplaces] PRIMARY KEY ([Id])
                                                , FOREIGN KEY ([TemplateId]) REFERENCES [RequestsFilter_Templates] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                );
                                                CREATE INDEX [IX_RequestsFilter_Template_RuleReplaces_TemplateId] ON [RequestsFilter_Template_RuleReplaces] ([TemplateId] ASC);
                                            ");

                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [RequestsFilter_Template_RuleOverrides] (
                                                  [Id] INTEGER  NOT NULL
                                                , [IsActive] bigint  NOT NULL
                                                , [Method] bigint  NOT NULL
                                                , [TemplateId] bigint  NOT NULL
                                                , [order] bigint  NOT NULL
                                                , [rule] text NULL
                                                , CONSTRAINT [sqlite_master_PK_RequestsFilter_Template_RuleOverrides] PRIMARY KEY ([Id])
                                                , FOREIGN KEY ([TemplateId]) REFERENCES [RequestsFilter_Templates] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                );
                                                CREATE INDEX [IX_RequestsFilter_Template_RuleOverrides_TemplateId] ON [RequestsFilter_Template_RuleOverrides] ([TemplateId] ASC);
                                            ");

                            goto case 9;
                        }
                            #endregion

                        case 9:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_AntiBot] ADD [BackgroundCheck] BIGINT DEFAULT 0 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_AntiBot] ADD [CountBackgroundRequest] BIGINT DEFAULT 2 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_AntiBot] ADD [BackgroundCheckToAddExtensions] TEXT NULL ;");
                            break;
                        }
                        }

                        // Миграция на 0.1.*
                        vSql.Patch = 0;
                        goto case 0.1;
                    }
                        #endregion

                    case 0.1:
                    {
                        switch (vSql.Patch)
                        {
                        case 0:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_AntiBot] ADD [BackgroundHourCacheToIP] BIGINT DEFAULT 0 NOT NULL ;");
                            goto case 1;
                        }

                        case 1:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_LimitRequest] ADD [BlockType] BIGINT DEFAULT 0 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_LimitRequest] ADD [MaxRequestToAgainСheckingreCAPTCHA] BIGINT DEFAULT 300 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domains] ADD [Auth2faToPasswd] TEXT NULL ;");
                            goto case 2;
                        }

                        case 2:
                        {
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [Auth_Sessions] (
                                                  [Id] INTEGER  NOT NULL
                                                , [Confirm2FA] bigint  NOT NULL
                                                , [Expires] text NOT NULL
                                                , [HashPasswdToRoot] text NULL
                                                , [IP] text NULL
                                                , [Session] text NULL
                                                , CONSTRAINT [sqlite_master_PK_Auth_Sessions] PRIMARY KEY ([Id])
                                                );
                                            ");
                            goto case 3;
                        }

                        case 3:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [Auth_Sessions] ADD [CreateTime] TEXT DEFAULT [2018-04-24 10:57:30.9735464] NOT NULL ;");
                            goto case 4;
                        }

                            #region case 4
                        case 4:
                        {
                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [SyncBackup_db_Tasks] (
                                                  [Id] INTEGER  NOT NULL
                                                , [Description] text NULL
                                                , [JobStatus] bigint  NOT NULL
                                                , [LastSync] text NOT NULL
                                                , [SuncTime] bigint  NOT NULL
                                                , [TypeDb] bigint  NOT NULL
                                                , CONSTRAINT [sqlite_master_PK_SyncBackup_db_Tasks] PRIMARY KEY ([Id])
                                                );
                                            ");

                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [SyncBackup_db_Task_Conf] (
                                                  [Id] INTEGER  NOT NULL
                                                , [AddBackupTime] bigint  NOT NULL
                                                , [Compression] bigint  NOT NULL
                                                , [DumpDatabases] text NULL
                                                , [IgnoreDatabases] text NULL
                                                , [TaskId] bigint  NOT NULL
                                                , [Whence] text NULL
                                                , CONSTRAINT [sqlite_master_PK_SyncBackup_db_Task_Conf] PRIMARY KEY ([Id])
                                                , FOREIGN KEY ([TaskId]) REFERENCES [SyncBackup_db_Tasks] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                );
                                                CREATE UNIQUE INDEX [IX_SyncBackup_db_Task_Conf_TaskId] ON [SyncBackup_db_Task_Conf] ([TaskId] ASC);
                                            ");

                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [SyncBackup_db_Task_MySQL] (
                                                  [Id] INTEGER  NOT NULL
                                                , [Host] text NULL
                                                , [Password] text NULL
                                                , [Port] bigint  NOT NULL
                                                , [TaskId] bigint  NOT NULL
                                                , [User] text NULL
                                                , CONSTRAINT [sqlite_master_PK_SyncBackup_db_Task_MySQL] PRIMARY KEY ([Id])
                                                , FOREIGN KEY ([TaskId]) REFERENCES [SyncBackup_db_Tasks] ([Id]) ON DELETE CASCADE ON UPDATE NO ACTION
                                                );
                                                CREATE UNIQUE INDEX [IX_SyncBackup_db_Task_MySQL_TaskId] ON [SyncBackup_db_Task_MySQL] ([TaskId] ASC);
                                            ");

                            coreDB.Database.ExecuteSqlCommand(@"CREATE TABLE [SyncBackup_db_Reports] (
                                                  [Id] INTEGER  NOT NULL
                                                , [Category] text NULL
                                                , [ErrorMsg] text NULL
                                                , [Msg] text NULL
                                                , [Status] text NULL
                                                , [TaskId] bigint  NOT NULL
                                                , [Time] text NOT NULL
                                                , CONSTRAINT [sqlite_master_PK_SyncBackup_db_Reports] PRIMARY KEY ([Id])
                                                );
                                            ");

                            goto case 5;
                        }
                            #endregion

                        case 5:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE SyncBackup_db_Task_MySQL RENAME TO SyncBackup_db_Task_ConnectionConf;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE SyncBackup_db_Task_Conf RENAME TO SyncBackup_db_Task_DumpConf;");
                            goto case 6;
                        }

                        case 6:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [WhitePtrIPs] ADD [PTR] TEXT NULL ;");
                            goto case 7;
                        }

                        case 7:
                        {
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_NumberOfRequestDay] ADD [CountIPtables] BIGINT DEFAULT 0 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_NumberOfRequestMonth] ADD [CountIPtables] BIGINT DEFAULT 0 NOT NULL ;");
                            coreDB.Database.ExecuteSqlCommand("ALTER TABLE [RequestsFilter_Domain_AntiBot] ADD [HashKey] TEXT NULL ;");
                            goto case 8;
                        }

                        case 8:
                        {
                            // Миграция на 9
                            //goto case 9;
                            break;
                        }
                        }
                        break;
                    }
                    }
                    #endregion

                    // Сохраняем версию базы
                    coreDB.Version.Add(Startup.vSql);
                    coreDB.SaveChanges();
                }
            }
        }
Пример #22
0
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime applicationLifetime, IMemoryCache memoryCache)
        {
            #region Системные настройки
            loggerFactory.AddConsole();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            #endregion

            #region Добовляем порт в белый список
            if (Platform.Get == PlatformOS.Unix)
            {
                if (string.IsNullOrWhiteSpace(new Bash().Run("iptables -L INPUT -v -n 2>/dev/null | grep 8793")))
                {
                    new Bash().Run("iptables -I INPUT -p tcp --dport 8793 -j ACCEPT");
                }
            }
            #endregion

            #region Unix Socket
            try
            {
                applicationLifetime.ApplicationStarted.Register(() =>
                {
                    if (Platform.Get == PlatformOS.Unix || Platform.Get == PlatformOS.Docker)
                    {
                        ThreadPool.QueueUserWorkItem((s) =>
                        {
                            while (true)
                            {
                                // Ждем 3 секунды
                                Thread.Sleep(1000 * 3);

                                // Меняем права доступа
                                if (File.Exists("/var/run/ispcore.sock"))
                                {
                                    new Bash().Run("chmod 666 /var/run/ispcore.sock");
                                    return;
                                }
                            }
                        });
                    }
                });
            }
            catch { }
            #endregion

            // Создаем сервис
            Service.Create(memoryCache);

            // Регистрируем триггеры
            RegisteredTriggers.Initialize();

            #region Загружаем список BlockedIP в кеш
            using (CoreDB coreDB = Service.Get <CoreDB>())
            {
                // IP который нужно удалить
                string unlockip = string.Empty;
                if (File.Exists($"{Folders.Tmp}/unlockip.root"))
                {
                    unlockip = File.ReadAllText($"{Folders.Tmp}/unlockip.root").Trim();
                }

                // Загружаем IP адреса
                foreach (var item in coreDB.BlockedsIP.AsNoTracking())
                {
                    if (item.BlockingTime > DateTime.Now && item.typeBlockIP != TypeBlockIP.UserAgent)
                    {
                        // Белый IP
                        if (item.IP.Contains(unlockip))
                        {
                            continue;
                        }

                        // Модель
                        var data = new ModelIPtables(item.Description, item.BlockingTime);
                        IPtables.AddIPv4Or6(item.IP, data, item.typeBlockIP, item.BlockedHost);
                    }
                }
            }
            #endregion

            #region Загружаем список WhitePtrIP в кеш
            using (CoreDB coreDB = Service.Get <CoreDB>())
            {
                // Загружаем IP адреса
                foreach (var item in coreDB.WhitePtrIPs.AsNoTracking())
                {
                    // Добовляем IP в кеш
                    if (item.Expires > DateTime.Now)
                    {
                        memoryCache.Set(KeyToMemoryCache.WhitePtrIP(item.IPv4Or6), (byte)0, item.Expires);
                    }
                }
            }
            #endregion

            #region Загружаем список "Разрешенные доступы" в кеш
            foreach (var item in AccessIP.List())
            {
                // IP для кеша
                string ipCache = item.IP.Replace(".*", "").Replace(":*", "");

                switch (item.accessType)
                {
                case AccessType.all:
                    memoryCache.Set(KeyToMemoryCache.CheckLinkWhitelistToAll(item.host, ipCache), (byte)1, item.Expires);
                    break;

                case AccessType.Is2FA:
                    memoryCache.Set(KeyToMemoryCache.CheckLinkWhitelistTo2FA(item.host, ipCache), (byte)1, item.Expires);
                    break;

                case AccessType.allDomain:
                    memoryCache.Set(KeyToMemoryCache.CheckLinkWhitelistToAllDomain(ipCache), (byte)1, item.Expires);
                    break;
                }
            }
            #endregion

            #region Кеш  WhiteList / IPtables
            WhiteUserList.UpdateCache();
            Engine.Security.IPtables.UpdateCacheToUserAgent();
            #endregion

            #region Статичиские файлы
            var provider = new FileExtensionContentTypeProvider();
            provider.Mappings[".jgz"] = "application/javascript";
            app.UseStaticFiles(new StaticFileOptions
            {
                ContentTypeProvider = provider
            });
            #endregion

            #region IP-адрес клиента
            app.UseForwardedHeaders(new ForwardedHeadersOptions
            {
                ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto,
                KnownProxies     = { IPAddress.Parse("172.17.42.1"), IPAddress.Parse("127.0.0.1") },
            });
            #endregion

            // Страницы ошибок
            app.UseMvc(routes => {
                routes.MapRoute("ErrorPage-404", "404", new { controller = "Error", action = "_404" });
            });

            // Блокировка IP
            app.UseIPtablesMiddleware();

            #region Core API
            // Доступ запрещен с порта панели 8793
            app.UseCoreMiddleware();

            // Core CheckRequest
            app.Map("/core/check/request", ap => ap.Run(context =>
            {
                if (Startup.cmd.Timeout.core == 0)
                {
                    return(Engine.core.Check.Request.Check(context));
                }

                // Состояние потока
                bool RanToCompletion = false;

                // Завершаем подключение через ** секунд
                var token = new CancellationTokenSource(1000 * Startup.cmd.Timeout.core).Token;
                token.Register(() =>
                {
                    if (!RanToCompletion)
                    {
                        context.Abort();
                    }
                });

                // Проверка запроса
                var task        = Engine.core.Check.Request.Check(context);
                RanToCompletion = task.Status == TaskStatus.RanToCompletion;

                // Успех
                return(task);
            }));

            // Core API
            app.UseMvc(routes => {
                routes.MapRoute(null, "core/unlock/2fa", new { controller = "CoreUnlock2FA", action = "Index" });
                routes.MapRoute(null, "core/check/cookie", new { controller = "CoreCheckCookie", action = "Index" });
                routes.MapRoute(null, "core/check/recaptcha", new { controller = "CoreCheckRecaptcha", action = "Base" });
                routes.MapRoute(null, "core/check/recaptcha/limitrequest", new { controller = "CoreCheckRecaptcha", action = "LimitRequest" });
            });

            // AntiBotHub
            app.UseSignalR(routes => routes.MapHub <AntiBotHub>("/core/AntiBotHub"));

            // Генерация скриптов
            app.UseMvc(routes => {
                routes.MapRoute(null, "core/gen/antibot.js", new { controller = "CoreGenToAntiBot", action = "Index" });
            });

            // Заглушка для "Core API"
            app.Map("/core", ap => ap.Run(context => context.Response.WriteAsync("404  Not Found")));
            #endregion

            #region Открытый API
            {
                // Проверка авторизации
                app.UseAuthApiMiddleware();

                #region API - List
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "api/list/home/jurnal", new { controller = "ApiListHome", action = "Jurnal" });
                    routes.MapRoute(null, "api/list/notifications", new { controller = "ApiListNotifications", action = "Jurnal" });
                    routes.MapRoute(null, "api/list/jsondb", new { controller = "ApiListJsonDB", action = "Get" });

                    routes.MapRoute(null, "api/list/whitelist/system", new { controller = "ApiListWhitelistTo", action = "Systems" });

                    routes.MapRoute(null, "api/list/security/anti-ddos/stats/day", new { controller = "ApiListAntiDdos", action = "StatsDay" });
                    routes.MapRoute(null, "api/list/security/anti-ddos/stats/month", new { controller = "ApiListAntiDdos", action = "StatsMonth" });
                    routes.MapRoute(null, "api/list/security/anti-ddos/jurnal", new { controller = "ApiListAntiDdos", action = "Jurnal" });

                    routes.MapRoute(null, "api/list/security/iptables/blockedip", new { controller = "ApiListIptables", action = "BlockedsIP" });
                    routes.MapRoute(null, "api/list/security/av/report", new { controller = "ApiListAntiVirus", action = "Report" });

                    routes.MapRoute(null, "api/list/requests-filter/domain", new { controller = "ApiListDomain", action = "Domain" });
                    routes.MapRoute(null, "api/list/requests-filter/domains", new { controller = "ApiListDomain", action = "Domains" });
                    routes.MapRoute(null, "api/list/requests-filter/template", new { controller = "ApiListTemplate", action = "Template" });
                    routes.MapRoute(null, "api/list/requests-filter/templates", new { controller = "ApiListTemplate", action = "Templates" });
                    routes.MapRoute(null, "api/list/requests-filter/access", new { controller = "ApiListAccess", action = "Get" });

                    routes.MapRoute(null, "api/list/requests-filter/monitoring/stats/day", new { controller = "ApiListMonitoring", action = "StatsDay" });
                    routes.MapRoute(null, "api/list/requests-filter/monitoring/stats/month", new { controller = "ApiListMonitoring", action = "StatsMonth" });
                    routes.MapRoute(null, "api/list/requests-filter/monitoring/jurnal", new { controller = "ApiListMonitoring", action = "Jurnal" });

                    routes.MapRoute(null, "api/list/backup/io/task", new { controller = "ApiListBackupFiles", action = "Task" });
                    routes.MapRoute(null, "api/list/backup/io/tasks", new { controller = "ApiListBackupFiles", action = "Tasks" });
                    routes.MapRoute(null, "api/list/backup/io/operations", new { controller = "ApiListBackupFiles", action = "Operation" });

                    routes.MapRoute(null, "api/list/backup/db/task", new { controller = "ApiListBackupDatabase", action = "Task" });
                    routes.MapRoute(null, "api/list/backup/db/tasks", new { controller = "ApiListBackupDatabase", action = "Tasks" });
                    routes.MapRoute(null, "api/list/backup/db/operations", new { controller = "ApiListBackupDatabase", action = "Operation" });
                });
                #endregion

                #region API - Add
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "api/add/whitelist", new { controller = "ApiAddWhiteList", action = "Base" });
                    routes.MapRoute(null, "api/add/security/iptables", new { controller = "ApiAddIptables", action = "Base" });

                    routes.MapRoute(null, "api/add/backup/io/task", new { controller = "ApiAddBackupFiles", action = "Task" });
                    routes.MapRoute(null, "api/add/backup/io/ignore", new { controller = "ApiAddBackupFiles", action = "Ignore" });

                    routes.MapRoute(null, "api/add/backup/db/task", new { controller = "ApiAddBackupDatabase", action = "Task" });

                    routes.MapRoute(null, "api/add/requests-filter/template", new { controller = "ApiAddTemplate", action = "Base" });
                    routes.MapRoute(null, "api/add/requests-filter/template/rule", new { controller = "ApiAddRule", action = "RuleTemplate" });

                    routes.MapRoute(null, "api/add/requests-filter/domain", new { controller = "ApiAddDomain", action = "Domain" });
                    routes.MapRoute(null, "api/add/requests-filter/aliases", new { controller = "ApiAddDomain", action = "Aliases" });
                    routes.MapRoute(null, "api/add/requests-filter/domain/rule", new { controller = "ApiAddRule", action = "RuleDomain" });
                    routes.MapRoute(null, "api/add/requests-filter/domain/template", new { controller = "ApiAddDomain", action = "TemplatesId" });
                    routes.MapRoute(null, "api/add/requests-filter/domain/ignore", new { controller = "ApiAddDomain", action = "IgnoreLogs" });
                    routes.MapRoute(null, "api/add/requests-filter/access", new { controller = "ApiAddAccess", action = "Base" });
                });
                #endregion

                #region API - Remove
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "api/remove/whitelist/user", new { controller = "ApiRemoveWhiteList", action = "Users" });
                    routes.MapRoute(null, "api/remove/whitelist/system", new { controller = "ApiRemoveWhiteList", action = "Systems" });

                    routes.MapRoute(null, "api/remove/security/iptables", new { controller = "ApiRemoveIptables", action = "BlockedsIP" });
                    routes.MapRoute(null, "api/remove/security/antivirus", new { controller = "ApiRemoveAntivirus", action = "Base" });

                    routes.MapRoute(null, "api/remove/backup/io/task", new { controller = "ApiRemoveBackupFiles", action = "Task" });
                    routes.MapRoute(null, "api/remove/backup/io/ignore", new { controller = "ApiRemoveBackupFiles", action = "Ignore" });

                    routes.MapRoute(null, "api/remove/backup/db/task", new { controller = "ApiRemoveBackupDatabase", action = "Task" });

                    routes.MapRoute(null, "api/remove/requests-filter/rules/base", new { controller = "ApiRemoveRules", action = "Rule" });
                    routes.MapRoute(null, "api/remove/requests-filter/rules/replace", new { controller = "ApiRemoveRules", action = "RuleReplace" });
                    routes.MapRoute(null, "api/remove/requests-filter/rules/override", new { controller = "ApiRemoveRules", action = "RuleOverride" });
                    routes.MapRoute(null, "api/remove/requests-filter/rules/arg", new { controller = "ApiRemoveRules", action = "RuleArg" });
                    routes.MapRoute(null, "api/remove/requests-filter/alias", new { controller = "ApiRemoveDomain", action = "Alias" });
                    routes.MapRoute(null, "api/remove/requests-filter/domain", new { controller = "ApiRemoveDomain", action = "Base" });
                    routes.MapRoute(null, "api/remove/requests-filter/domain/template", new { controller = "ApiRemoveDomain", action = "Template" });
                    routes.MapRoute(null, "api/remove/requests-filter/domain/ignore", new { controller = "ApiRemoveDomain", action = "Ignore" });
                    routes.MapRoute(null, "api/remove/requests-filter/template", new { controller = "ApiRemoveTemplate", action = "Base" });
                    routes.MapRoute(null, "api/remove/requests-filter/access", new { controller = "ApiRemoveAccess", action = "Base" });
                });
                #endregion

                #region API - Common
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "api/common/av/start", new { controller = "ApiCommonAV", action = "Start" });
                    routes.MapRoute(null, "api/common/av/stop", new { controller = "ApiCommonAV", action = "Stop" });

                    routes.MapRoute(null, "api/common/template/export", new { controller = "ApiCommonTemplate", action = "Export" });
                    routes.MapRoute(null, "api/common/template/import", new { controller = "ApiCommonTemplate", action = "Import" });

                    routes.MapRoute(null, "api/common/backup/io/clearing/cache", new { controller = "ApiCommonBackupFiles", action = "ClearingCache" });
                    routes.MapRoute(null, "api/common/backup/io/recovery", new { controller = "ApiCommonBackupFiles", action = "Recovery" });
                });
                #endregion

                #region API - Edit
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "api/edit/settings/base", new { controller = "ApiEditSettingsToBase", action = "Base" });
                    routes.MapRoute(null, "api/edit/settings/cache", new { controller = "ApiEditSettingsToBase", action = "Cache" });
                    routes.MapRoute(null, "api/edit/settings/api", new { controller = "ApiEditSettingsToBase", action = "API" });
                    routes.MapRoute(null, "api/edit/settings/security", new { controller = "ApiEditSettingsToBase", action = "Security" });
                    routes.MapRoute(null, "api/edit/settings/passwd", new { controller = "ApiEditSettingsToBase", action = "Passwd" });
                    routes.MapRoute(null, "api/edit/settings/brute-force", new { controller = "ApiEditSettingsToBase", action = "BruteForce" });
                    routes.MapRoute(null, "api/edit/settings/anti-ddos", new { controller = "ApiEditSettingsToBase", action = "AntiDdos" });
                    routes.MapRoute(null, "api/edit/settings/antivirus", new { controller = "ApiEditSettingsToBase", action = "AntiVirus" });

                    routes.MapRoute(null, "api/edit/settings/service/email", new { controller = "ApiEditSettingsToService", action = "Email" });
                    routes.MapRoute(null, "api/edit/settings/service/telegram", new { controller = "ApiEditSettingsToService", action = "Telegram" });
                    routes.MapRoute(null, "api/edit/settings/service/sms", new { controller = "ApiEditSettingsToService", action = "SMS" });

                    routes.MapRoute(null, "api/edit/antibot/base", new { controller = "ApiEditAntiBot", action = "Base" });
                    routes.MapRoute(null, "api/edit/antibot/limit", new { controller = "ApiEditAntiBot", action = "Limit" });

                    routes.MapRoute(null, "api/edit/domain/base", new { controller = "ApiEditDomain", action = "Base" });
                    routes.MapRoute(null, "api/edit/domain/log", new { controller = "ApiEditDomain", action = "LogSettings" });
                    routes.MapRoute(null, "api/edit/domain/av", new { controller = "ApiEditDomain", action = "AntiVirus" });
                    routes.MapRoute(null, "api/edit/domain/antibot", new { controller = "ApiEditDomain", action = "AntiBot" });
                    routes.MapRoute(null, "api/edit/domain/limit/request", new { controller = "ApiEditDomain", action = "LimitRequest" });

                    routes.MapRoute(null, "api/edit/template", new { controller = "ApiEditTemplate", action = "Base" });

                    routes.MapRoute(null, "api/edit/backup/io/task", new { controller = "ApiEditBackupFiles", action = "Task" });
                    routes.MapRoute(null, "api/edit/backup/io/ftp", new { controller = "ApiEditBackupFiles", action = "FTP" });
                    routes.MapRoute(null, "api/edit/backup/io/webdav", new { controller = "ApiEditBackupFiles", action = "WebDav" });
                    routes.MapRoute(null, "api/edit/backup/io/onedrive", new { controller = "ApiEditBackupFiles", action = "OneDrive" });

                    routes.MapRoute(null, "api/edit/backup/db/task", new { controller = "ApiEditBackupDatabase", action = "Task" });
                    routes.MapRoute(null, "api/edit/backup/db/task/dumpconf", new { controller = "ApiEditBackupDatabase", action = "DumpConf" });
                    routes.MapRoute(null, "api/edit/backup/db/connectionconf", new { controller = "ApiEditBackupDatabase", action = "ConnectionConf" });
                });
                #endregion
            }
            #endregion

            #region Авторизация
            // Страница авторизации
            app.UseMvc(routes => {
                routes.MapRoute(null, "auth", new { controller = "AuthToBase", action = "Index" });
                routes.MapRoute(null, "auth/unlock", new { controller = "AuthToBase", action = "Unlock" });
                routes.MapRoute(null, "auth/signout", new { controller = "AuthToBase", action = "SignOut" });
            });

            // Проверка авторизации
            app.UseAuthMiddleware();

            // Страница 2FA
            app.UseMvc(routes => {
                routes.MapRoute(null, "auth/confirm", new { controller = "AuthToConfirm", action = "Index" });
                routes.MapRoute(null, "auth/confirm/unlock", new { controller = "AuthToConfirm", action = "Unlock" });
            });
            #endregion

            // Главная страница
            app.UseMvc(routes => {
                routes.MapRoute(null, "", new { controller = "Home", action = "Index" });
            });

            #region API
            // FAQ
            app.UseMvc(routes => routes.MapRoute(null, "api/faq", new { controller = "ApiFaq", action = "Index" }));

            // Заглушка для "API"
            app.Map("/api", ap => ap.Run(context => context.Response.WriteAsync("404  Not Found")));
            #endregion

            #region Настройки
            app.UseMvc(routes => {
                routes.MapRoute(null, "settings", new { controller = "SettingsToBase", action = "Index" });
                routes.MapRoute(null, "settings/save/base", new { controller = "SettingsToBase", action = "Save" });

                routes.MapRoute(null, "settings/whitelist", new { controller = "SettingsToUserWhiteList", action = "Index" });
                routes.MapRoute(null, "settings/save/whitelist", new { controller = "SettingsToUserWhiteList", action = "Save" });
                routes.MapRoute(null, "settings/remove/whitelist", new { controller = "SettingsToUserWhiteList", action = "Remove" });
                routes.MapRoute(null, "settings/whitelist/export", new { controller = "SettingsToUserWhiteList", action = "Export" });
                routes.MapRoute(null, "settings/whitelist/import", new { controller = "SettingsToUserWhiteList", action = "Import" });

                routes.MapRoute(null, "settings/whitelist/system", new { controller = "SettingsToSystemWhiteList", action = "Index" });
                routes.MapRoute(null, "settings/remove/whitelist/system", new { controller = "SettingsToSystemWhiteList", action = "Remove" });

                routes.MapRoute(null, "settings/service", new { controller = "SettingsToService", action = "Index" });
                routes.MapRoute(null, "settings/save/service", new { controller = "SettingsToService", action = "Save" });
            });
            #endregion

            #region Безопастность системы
            // Брандмауэр
            app.UseMvc(routes => {
                routes.MapRoute(null, "security/iptables", new { controller = "SecurityToIPtables", action = "Index" });
                routes.MapRoute(null, "security/iptables/remove", new { controller = "SecurityToIPtables", action = "Remove" });
                routes.MapRoute(null, "security/iptables/add", new { controller = "SecurityToIPtables", action = "Add" });
            });

            // Антивирус
            app.UseMvc(routes => {
                routes.MapRoute(null, "security/antivirus", new { controller = "SecurityToAntiVirus", action = "Index" });
                routes.MapRoute(null, "security/antivirus/save", new { controller = "SecurityToAntiVirus", action = "Save" });
                routes.MapRoute(null, "security/antivirus/remove", new { controller = "SecurityToAntiVirus", action = "Remove" });
                routes.MapRoute(null, "security/antivirus/start", new { controller = "SecurityToAntiVirus", action = "Start" });
                routes.MapRoute(null, "security/antivirus/stop", new { controller = "SecurityToAntiVirus", action = "Stop" });
            });

            // AntiDdos
            if (Platform.Get == PlatformOS.Unix)
            {
                app.UseMvc(routes =>
                {
                    routes.MapRoute(null, "security/anti-ddos", new { controller = "SecurityToAntiDdos", action = "Index" });
                    routes.MapRoute(null, "security/anti-ddos/save", new { controller = "SecurityToAntiDdos", action = "Save" });
                });
            }

            // Anti-Bot
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "security/antibot", new { controller = "SecurityToAntiBot", action = "Index" });
                routes.MapRoute(null, "security/antibot/save", new { controller = "SecurityToAntiBot", action = "Save" });
            });
            #endregion

            #region Фильтрация запросов
            // Views
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domains", new { controller = "RequestsFilterToDomains", action = "Index" });
                routes.MapRoute(null, "requests-filter/templates", new { controller = "RequestsFilterToTemplates", action = "Index" });
                routes.MapRoute(null, "requests-filter/monitoring", new { controller = "RequestsFilterToMonitoring", action = "Index" });
            });

            // Common
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/common/remove/rule", new { controller = "RequestsFilterToCommon", action = "RemoveToRule" });
                routes.MapRoute(null, "requests-filter/common/remove/rulereplace", new { controller = "RequestsFilterToCommon", action = "RemoveToRuleReplace" });
                routes.MapRoute(null, "requests-filter/common/remove/ruleoverride", new { controller = "RequestsFilterToCommon", action = "RemoveToRuleOverride" });
                routes.MapRoute(null, "requests-filter/common/remove/rulearg", new { controller = "RequestsFilterToCommon", action = "RemoveToRuleArg" });
                routes.MapRoute(null, "requests-filter/common/remove/alias", new { controller = "RequestsFilterToCommon", action = "RemoveToAlias" });
            });

            // Шаблон
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/template", new { controller = "RequestsFilterToTemplate", action = "Index" });
                routes.MapRoute(null, "requests-filter/template/save", new { controller = "RequestsFilterToTemplate", action = "Save" });
                routes.MapRoute(null, "requests-filter/template/remove", new { controller = "RequestsFilterToTemplate", action = "Remove" });
                routes.MapRoute(null, "requests-filter/template/import", new { controller = "RequestsFilterToTemplate", action = "Import" });
                routes.MapRoute(null, "requests-filter/template/export", new { controller = "RequestsFilterToTemplate", action = "Export" });
            });

            // Разрешенные доступы
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/access", new { controller = "RequestsFilterToAccess", action = "Index" });
                routes.MapRoute(null, "requests-filter/access/open", new { controller = "RequestsFilterToAccess", action = "Open" });
                routes.MapRoute(null, "requests-filter/access/remove", new { controller = "RequestsFilterToAccess", action = "Remove" });
            });
            #endregion

            #region Фильтрация запросов - Домен
            // Домен - Главная/FAQ
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/base", new { controller = "RequestsFilterToDomainBase", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/faq", new { controller = "RequestsFilterToDomainBase", action = "Faq" });
                routes.MapRoute(null, "requests-filter/domain/remove", new { controller = "RequestsFilterToDomainBase", action = "Remove" });
                routes.MapRoute(null, "requests-filter/domain/save/base", new { controller = "RequestsFilterToDomainBase", action = "Save" });
                routes.MapRoute(null, "requests-filter/domain/import", new { controller = "RequestsFilterToDomainBase", action = "Import" });
                routes.MapRoute(null, "requests-filter/domain/export", new { controller = "RequestsFilterToDomainBase", action = "Export" });
            });

            // Домен - Алиасы
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/aliases", new { controller = "RequestsFilterToDomainAliases", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/aliases", new { controller = "RequestsFilterToDomainAliases", action = "Save" });
            });

            // Домен - Правила
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/rules", new { controller = "RequestsFilterToDomainRules", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/rules", new { controller = "RequestsFilterToDomainRules", action = "Save" });
            });

            // Домен - Настройки журнала
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/logsettings", new { controller = "RequestsFilterToDomainLogSettings", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/logsettings", new { controller = "RequestsFilterToDomainLogSettings", action = "Save" });
            });

            // Домен - Антивирус
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/av", new { controller = "RequestsFilterToDomainAv", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/av", new { controller = "RequestsFilterToDomainAv", action = "Save" });
            });

            // Домен - AntiBot
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/antibot", new { controller = "RequestsFilterToDomainAntiBot", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/antibot", new { controller = "RequestsFilterToDomainAntiBot", action = "Save" });
            });

            // Домен - Лимит запросов
            app.UseMvc(routes => {
                routes.MapRoute(null, "requests-filter/domain/limitrequest", new { controller = "RequestsFilterToDomainLimitRequest", action = "Index" });
                routes.MapRoute(null, "requests-filter/domain/save/limitrequest", new { controller = "RequestsFilterToDomainLimitRequest", action = "Save" });
            });
            #endregion

            #region SyncBackup - IO
            // Views
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/io/tasks", new { controller = "SyncBackupFilesToTasks", action = "Index" });
                routes.MapRoute(null, "backup/io/operation", new { controller = "SyncBackupFilesToOperation", action = "Index" });
            });

            // Задание
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/io/task", new { controller = "SyncBackupFilesToTask", action = "Index" });
                routes.MapRoute(null, "backup/io/task/remove", new { controller = "SyncBackupFilesToTask", action = "Remove" });
                routes.MapRoute(null, "backup/io/task/save", new { controller = "SyncBackupFilesToTask", action = "Save" });
                routes.MapRoute(null, "backup/io/task/clearing-cache", new { controller = "SyncBackupFilesToTask", action = "ClearingCache" });
            });

            // Улиты
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/io/tools", new { controller = "SyncBackupFilesToTools", action = "Index" });
                routes.MapRoute(null, "backup/io/tools/recover", new { controller = "SyncBackupFilesToTools", action = "Recovery" });
            });

            // Получение токенов
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/io/authorize/onedrive", new { controller = "SyncBackupFilesToAuthorize", action = "OneDrive" });
            });
            #endregion

            #region SyncBackup - DB
            // Views
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/db/tasks", new { controller = "SyncBackupDatabaseToTasks", action = "Index" });
                routes.MapRoute(null, "backup/db/operation", new { controller = "SyncBackupDatabaseToOperation", action = "Index" });
            });

            // Задание
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "backup/db/task", new { controller = "SyncBackupDatabaseToTask", action = "Index" });
                routes.MapRoute(null, "backup/db/task/remove", new { controller = "SyncBackupDatabaseToTask", action = "Remove" });
                routes.MapRoute(null, "backup/db/task/save", new { controller = "SyncBackupDatabaseToTask", action = "Save" });
            });
            #endregion

            #region Файловый менеджер
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "file-manager", new { controller = "ToolsToFileManager", action = "Index" });
                routes.MapRoute(null, "file-manager/target/{targetfile}", new { controller = "ToolsToFileManager", action = "Target" });
                routes.MapRoute(null, "file-manager/connector", new { controller = "ToolsToFileManager", action = "Connector" });
                routes.MapRoute(null, "file-manager/thumb/{hash}", new { controller = "ToolsToFileManager", action = "Thumbs" });
            });
            #endregion

            #region Триггеры
            app.UseMvc(routes =>
            {
                routes.MapRoute(null, "triggers", new { controller = "ToolsToTriggers", action = "Index" });

                routes.MapRoute(null, "trigger", new { controller = "ToolsToTriggerSettings", action = "Index" });
                routes.MapRoute(null, "trigger/faq", new { controller = "ToolsToTriggerSettings", action = "FAQ" });
                routes.MapRoute(null, "trigger/save", new { controller = "ToolsToTriggerSettings", action = "Save" });
                routes.MapRoute(null, "trigger/remove", new { controller = "ToolsToTriggerSettings", action = "Remove" });
                routes.MapRoute(null, "trigger/export", new { controller = "ToolsToTriggerSettings", action = "Export" });
                routes.MapRoute(null, "trigger/import", new { controller = "ToolsToTriggerSettings", action = "Import" });

                routes.MapRoute(null, "trigger/nodes", new { controller = "ToolsToTriggerNodes", action = "Index" });
                routes.MapRoute(null, "trigger/nodes/save", new { controller = "ToolsToTriggerNodes", action = "Save" });
            });
            #endregion

            // Уведомления
            app.UseMvc(routes => {
                routes.MapRoute(null, "notifications", new { controller = "Notifications", action = "Index" });
            });

            // Ошибка 404
            app.Run(async(context) =>
            {
                await RewriteTo.Local(context, "404" + (context.Request.QueryString.Value.Contains("ajax=true") ? "?ajax=true" : ""));
            });
        }
Пример #23
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            #region Очистка базы 'Операции' и папки 'ReportSync'
            if (memoryCache.TryGetValue("CronSyncBackupIO:ClearDB", out DateTime CronSyncBackupClearDB))
            {
                // Если дата отличается от текущей
                if (CronSyncBackupClearDB.Day != DateTime.Now.Day)
                {
                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.Read);

                    // Обновляем кеш
                    memoryCache.Set("CronSyncBackupIO:ClearDB", DateTime.Now);

                    // Чистим базу
                    foreach (var note in coreDB.SyncBackup_Notations.AsNoTracking())
                    {
                        // Если записи больше 90 дней
                        if ((DateTime.Now - note.Time).TotalDays > 90)
                        {
                            // Удаляем заметку
                            coreDB.SyncBackup_Notations.RemoveAttach(coreDB, note.Id);
                        }
                    }

                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);

                    // Удаляем старые файлы
                    foreach (var intFile in Directory.GetFiles(Folders.ReportSync, "*.*"))
                    {
                        try
                        {
                            if ((DateTime.Now - File.GetLastWriteTime(intFile)).TotalDays > 90)
                            {
                                File.Delete(intFile);
                            }
                        }
                        catch { }
                    }

                    // Раз в сутки
                    GC.Collect(GC.MaxGeneration);
                }
            }
            else
            {
                // Создаем кеш задним числом
                memoryCache.Set("CronSyncBackupIO:ClearDB", DateTime.Now.AddDays(-1));
            }
            #endregion

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.Read);

            // Получаем весь список заданий
            var Alltasks = coreDB.SyncBackup_Tasks.Include(f => f.FTP).Include(o => o.OneDrive).Include(dav => dav.WebDav).Include(ignr => ignr.IgnoreFileOrFolders).ToList();

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.ReadOrWrite);

            // Проходим задания
            foreach (var task in Alltasks)
            {
                // Пропускаем задания которые не требуют выполнения
                if (task.JobStatus != JobStatus.on || task.LastSync > DateTime.Now.AddMinutes(-task.SuncTime))
                {
                    continue;
                }

                // Кеш
                DateTime NewCacheSync = DateTime.Now;
                bool     IsOk         = false;

                #region Добовляем задание в WorkNote
                CancellationToken cancellationToken = new CancellationToken();
                var WorkNoteNotation = new Notation()
                {
                    TaskId   = task.Id,
                    Category = "Бэкап",
                    Msg      = $"Задание: {task.Description}",
                    Time     = DateTime.Now,
                    More     = new List <More>()
                    {
                        new More("Состояние", "Выполняется")
                    }
                };
                CoreDB.SyncBackupWorkNote.Add(WorkNoteNotation, cancellationToken);
                #endregion

                // Обновляем CacheSync
                if (task.CacheSync > task.CacheExpires)
                {
                    SqlToMode.SetMode(SqlMode.Read);
                    task.CacheSync    = default(DateTime);
                    task.CacheExpires = DateTime.Now.AddDays(12);
                    coreDB.SaveChanges();
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);
                }

                //
                Trigger.OnStartJob((task.Id, task.TypeSunc));

                // Создание отчета по ошибкам
                Report report = new Report(task);

                // Выполняем задание
                Sync(task, new RemoteServer(task.TypeSunc, task.FTP, task.WebDav, task.OneDrive, report, out string NewRefreshTokenToOneDrive), WorkNoteNotation, out List <More> ResponseNameAndValue, ref IsOk);

                // Сохраняем отчет об ошибках (если есть ошибки)
                report.SaveAndDispose(ref ResponseNameAndValue);

                // Чистим WorkNote
                CoreDB.SyncBackupWorkNote.Take(cancellationToken);

                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.Read);

                // Добовляем задание в список завершеных операций
                coreDB.SyncBackup_Notations.Add(new Notation()
                {
                    TaskId   = task.Id,
                    Category = "Бэкап",
                    Msg      = $"Задание: {task.Description}",
                    Time     = DateTime.Now,
                    More     = ResponseNameAndValue,
                });

                // Завершаем задание
                if (IsOk)
                {
                    task.LastSync  = DateTime.Now;
                    task.CacheSync = NewCacheSync;
                }

                // Меняем токен
                if (!string.IsNullOrWhiteSpace(NewRefreshTokenToOneDrive))
                {
                    task.OneDrive.RefreshToken = NewRefreshTokenToOneDrive;
                }

                coreDB.SaveChanges();

                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.ReadOrWrite);

                //
                Trigger.OnStopJob((task.Id, task.TypeSunc, IsOk));
            }

            IsRun = false;
        }
Пример #24
0
        public JsonResult Recovery(Task task, TypeRecovery typeRecovery, IDictionary <string, string> nameAndValue, bool IsAPI = false)
        {
            #region Демо режим
            if (Platform.IsDemo)
            {
                return(Json(new Text("Операция недоступна в демо-режиме")));
            }
            #endregion

            DateTime DateRecovery = default(DateTime);

            #region Проверка данных
            if (string.IsNullOrWhiteSpace(task.Description))
            {
                return(Json(new Text("Имя задания не может быть пустым")));
            }

            if (string.IsNullOrWhiteSpace(task.Whence))
            {
                return(Json(new Text("Локальный каталог не может быть пустым")));
            }

            if (string.IsNullOrWhiteSpace(task.Where))
            {
                return(Json(new Text("Удаленный каталог не может быть пустым")));
            }

            switch (task.TypeSunc)
            {
            case TypeSunc.SFTP:
            case TypeSunc.FTP:
            {
                if (string.IsNullOrWhiteSpace(task.FTP.HostOrIP) || string.IsNullOrWhiteSpace(task.FTP.Login) || string.IsNullOrWhiteSpace(task.FTP.Passwd))
                {
                    return(Json(new Text("Настройки 'FTP/SFTP' имеют недопустимое значение")));
                }
                break;
            }

            case TypeSunc.WebDav:
            {
                if (string.IsNullOrWhiteSpace(task.WebDav.url) || string.IsNullOrWhiteSpace(task.WebDav.Login) || string.IsNullOrWhiteSpace(task.WebDav.Passwd))
                {
                    return(Json(new Text("Настройки 'WebDav' имеют недопустимое значение")));
                }
                break;
            }

            case TypeSunc.OneDrive:
            {
                if (string.IsNullOrWhiteSpace(task.OneDrive.ApplicationId) || string.IsNullOrWhiteSpace(task.OneDrive.RefreshToken))
                {
                    return(Json(new Text("Настройки 'OneDrive' имеют недопустимое значение")));
                }
                break;
            }
            }

            if (task.EncryptionAES && string.IsNullOrWhiteSpace(task.PasswdAES))
            {
                return(Json(new Text("Пароль для шифрования файлов не может быть пустым")));
            }

            if (typeRecovery == TypeRecovery.Date && nameAndValue.TryGetValue("TypeRecoveryToDate", out string DateRecoveryTostring) && !DateTime.TryParse(DateRecoveryTostring, out DateRecovery))
            {
                return(Json(new Text("Отметка бэкапа имеет неправильный формат")));
            }
            #endregion

            // Искать файлы только в текущем каталоге
            bool SearchToCurrentDirectory = false;
            if (nameAndValue.TryGetValue("SearchOption", out string SearchOption) && SearchOption == "CurrentDirectory")
            {
                SearchToCurrentDirectory = true;
            }

            // Выполняем задание в потоке
            ThreadPool.QueueUserWorkItem(ob =>
            {
                #region Добовляем задание в WorkNote
                CancellationToken cancellationToken = new CancellationToken();
                var WorkNoteNotation = new Notation()
                {
                    TaskId   = task.Id,
                    Category = "Восстановление",
                    Msg      = $"Задание: {task.Description}",
                    Time     = DateTime.Now,
                    More     = new List <More>()
                    {
                        new More("Состояние", "Выполняется поиск всех папок")
                    }
                };
                CoreDB.SyncBackupWorkNote.Add(WorkNoteNotation, cancellationToken);
                #endregion

                // Создание отчета по ошибкам
                Report report = new Report(task);

                // Выполняем задание
                Tools.Recovery(task, new RemoteServer(task.TypeSunc, task.FTP, task.WebDav, task.OneDrive, report, out _), WorkNoteNotation, out List <More> ResponseNameAndValue, typeRecovery, DateRecovery, SearchToCurrentDirectory);

                // Сохраняем отчет об ошибках (если есть ошибки)
                report.SaveAndDispose(ref ResponseNameAndValue);

                // Чистим WorkNote
                CoreDB.SyncBackupWorkNote.Take(cancellationToken);

                #region Сохраняем данные задание в базе
                SqlToMode.SetMode(SqlMode.Read);
                using (CoreDB coreDB = Service.Get <CoreDB>())
                {
                    // Добовляем задание в список завершеных операций
                    coreDB.SyncBackup_Notations.Add(new Notation()
                    {
                        TaskId   = task.Id,
                        Category = "Восстановление",
                        Msg      = $"Задание: {task.Description}",
                        Time     = DateTime.Now,
                        More     = ResponseNameAndValue,
                    });

                    // Сохраняем базу
                    coreDB.SaveChanges();
                }
                SqlToMode.SetMode(SqlMode.ReadOrWrite);
                #endregion
            });

            // Отдаем ответ
            if (IsAPI)
            {
                return(Json(new TrueOrFalse(true)));
            }
            return(Json(new Text("Задание добавлено на обработку")));
        }
Пример #25
0
        public static void Run(CoreDB coreDB, JsonDB jsonDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            if (!memoryCache.TryGetValue("Cron-UpdateAV", out _))
            {
                memoryCache.Set("Cron-UpdateAV", (byte)1, Startup.AbsoluteExpirationToAPI);

                try
                {
                    HttpClient client   = new HttpClient();
                    string     vers     = client.GetStringAsync("http://cdn.core-system.org/isp/av/vers.txt").Result;
                    string     old_vers = File.ReadAllText($"{Folders.AV}/vers.txt");
                    if (Regex.IsMatch(vers, "^[0-9]+-[0-9]+-[0-9]+([\n\r]+)?$") && vers != old_vers)
                    {
                        if (Download("ai-bolit.php", "new_ai-bolit.php") && Download("AIBOLIT-WHITELIST.db", "new_AIBOLIT-WHITELIST.db"))
                        {
                            if (File.Exists($"{Folders.AV}/ai-bolit.php"))
                            {
                                File.Delete($"{Folders.AV}/ai-bolit.php");
                            }

                            if (File.Exists($"{Folders.AV}/AIBOLIT-WHITELIST.db"))
                            {
                                File.Delete($"{Folders.AV}/AIBOLIT-WHITELIST.db");
                            }

                            File.Move($"{Folders.AV}/new_ai-bolit.php", $"{Folders.AV}/ai-bolit.php");
                            File.Move($"{Folders.AV}/new_AIBOLIT-WHITELIST.db", $"{Folders.AV}/AIBOLIT-WHITELIST.db");
                            File.WriteAllText($"{Folders.AV}/vers.txt", vers);

                            // Добовляем данные в базу
                            SqlToMode.SetMode(SqlMode.Read);
                            coreDB.Notations.Add(new Notation()
                            {
                                Category = "Обновления",
                                Msg      = "Обновлен антивирус AI-Bolit",
                                Time     = DateTime.Now,
                                More     = new List <More>()
                                {
                                    new More("Предыдущая версия", old_vers.Replace('-', '.')),
                                    new More("Текущая версия", vers.Replace('-', '.'))
                                }
                            });

                            // Сохраняем базу
                            coreDB.SaveChanges();
                            SqlToMode.SetMode(SqlMode.ReadOrWrite);

                            // Обновляем CountNotification
                            jsonDB.Base.CountNotification++;
                            jsonDB.Save();
                        }
                    }
                }
                catch { }
            }

            IsRun = false;
        }
Пример #26
0
        public static void Run(CoreDB coreDB)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.Read);

            // Получаем весь список заданий
            var Alltasks = coreDB.RequestsFilter_Domains.Where(i => i.av.JobStatus == JobStatus.on && DateTime.Now.AddMinutes(-i.av.CheckEveryToMinute) > i.av.LastRun).Include(i => i.av).Include(i => i.Aliases).ToList();

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.ReadOrWrite);

            // Проходим задания
            foreach (var task in Alltasks)
            {
                // Нету PHP
                if (!File.Exists(task.av.php))
                {
                    continue;
                }

                #region Локальный метод - "RunAV"
                void RunAV(string progress_id)
                {
                    #region Создаем команду
                    StringBuilder comand = new StringBuilder();
                    comand.Append($"--path={task.av.path} ");

                    if (!string.IsNullOrWhiteSpace(task.av.skip))
                    {
                        comand.Append($"--skip={task.av.skip} ");
                    }

                    if (!string.IsNullOrWhiteSpace(task.av.scan))
                    {
                        comand.Append($"--scan={task.av.scan} ");
                    }

                    comand.Append($"--mode={task.av.mode} ");
                    comand.Append($"--memory={task.av.memory}M ");
                    comand.Append($"--size={task.av.size}K ");
                    comand.Append($"--delay={task.av.delay} ");
                    #endregion

                    // Имя отчета
                    string report = $"{Models.Security.AntiVirus.name}_{Models.Security.AntiVirus.vers}_{DateTime.Now.ToString("HH-mm_dd-MM-yyy")}{task.av.path.Replace("/", "_-_")}";

                    // Запускаем процесс bash
                    Bash bash = new Bash();
                    bash.Run($"{task.av.php} {Folders.AV}/ai-bolit.php {comand.ToString()} --progress={Folders.AV}/progress_id-{progress_id}.json --report={Folders.ReportsAV}/{report}.html >/dev/null 2>/dev/null");
                }

                #endregion

                // Проверяем папки алиасов
                foreach (var alias in task.Aliases)
                {
                    if (string.IsNullOrWhiteSpace(alias.Folder))
                    {
                        continue;
                    }

                    RunAV($"{task.Id}.{alias.Id}");
                }

                // Задание самого домена
                RunAV(task.Id.ToString());

                // Обновляем LastRun
                SqlToMode.SetMode(SqlMode.Read);
                task.av.LastRun = DateTime.Now;
                coreDB.SaveChanges();
                SqlToMode.SetMode(SqlMode.ReadOrWrite);
            }

            IsRun = false;
        }
Пример #27
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            #region Очистка базы - "Отчеты"
            if (memoryCache.TryGetValue("CronSyncBackupDB:ClearDB", out DateTime CronSyncBackupClearDB))
            {
                // Если дата отличается от текущей
                if (CronSyncBackupClearDB.Day != DateTime.Now.Day)
                {
                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.Read);

                    // Обновляем кеш
                    memoryCache.Set("CronSyncBackupDB:ClearDB", DateTime.Now);

                    // Чистим базу
                    foreach (var note in coreDB.SyncBackup_db_Reports.AsNoTracking())
                    {
                        // Если записи больше 90 дней
                        if ((DateTime.Now - note.Time).TotalDays > 90)
                        {
                            // Удаляем отчет
                            coreDB.SyncBackup_db_Reports.RemoveAttach(coreDB, note.Id);
                        }
                    }

                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);

                    // Раз в сутки
                    GC.Collect(GC.MaxGeneration);
                }
            }
            else
            {
                // Создаем кеш задним числом
                memoryCache.Set("CronSyncBackupDB:ClearDB", DateTime.Now.AddDays(-1));
            }
            #endregion

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.Read);

            // Получаем весь список заданий
            var Alltasks = coreDB.SyncBackup_db_Tasks.Include(i => i.DumpConf).Include(i => i.ConnectionConf).ToList();

            // Меняем режим доступа к SQL
            SqlToMode.SetMode(SqlMode.ReadOrWrite);

            // Проходим задания
            foreach (Task task in Alltasks)
            {
                // Пропускаем задания которые не требуют выполнения
                if (task.JobStatus != JobStatus.on || task.LastSync > DateTime.Now.AddMinutes(-task.SuncTime))
                {
                    continue;
                }

                //
                Trigger.OnStartJob((task.Id, task.TypeDb));

                // Выполняем задание
                Dump(task, out bool IsOk, out string ErrorMsg);

                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.Read);

                // Добовляем задание в список завершеных операций
                coreDB.SyncBackup_db_Reports.Add(new Report()
                {
                    TaskId   = task.Id,
                    Category = $"{task.TypeDb.ToString()}",
                    Msg      = $"Задание: {task.Description}",
                    Time     = DateTime.Now,
                    Status   = IsOk ? "Задание выполнено без ошибок" : "Задание выполнено с ошибками",
                    ErrorMsg = ErrorMsg,
                });

                // Завершаем задание
                task.LastSync = DateTime.Now;
                coreDB.SaveChanges();

                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.ReadOrWrite);

                //
                Trigger.OnStopJob((task.Id, task.TypeDb, IsOk, ErrorMsg));
            }

            IsRun = false;
        }
Пример #28
0
        public static void Run(CoreDB coreDB, IMemoryCache memoryCache)
        {
            if (IsRun)
            {
                return;
            }
            IsRun = true;

            #region IspNumberOfRequestToHour
            // Если есть кеш за прошлый час
            var TimeIspNumberOfRequestDay = DateTime.Now.AddHours(-1);
            if (memoryCache.TryGetValue(KeyToMemoryCache.IspNumberOfRequestToHour(TimeIspNumberOfRequestDay), out IDictionary <string, NumberOfRequestHour> DataNumberOfRequestToHour))
            {
                SqlToMode.SetMode(SqlMode.Read);
                coreDB.ChangeTracker.AutoDetectChangesEnabled = false;

                // Записываем данные в базу
                foreach (var item in DataNumberOfRequestToHour)
                {
                    coreDB.RequestsFilter_NumberOfRequestDay.Add(new NumberOfRequestDay()
                    {
                        Host     = item.Key,
                        Time     = TimeIspNumberOfRequestDay,
                        Count200 = item.Value.Count200,
                        Count303 = item.Value.Count303,
                        Count401 = item.Value.Count401,
                        Count403 = item.Value.Count403,
                        Count500 = item.Value.Count500,
                        Count2FA = item.Value.Count2FA,
                    });
                }

                // Сохраняем базу
                coreDB.SaveChanges();

                // Разрешаем записывать данные в SQL
                SqlToMode.SetMode(SqlMode.ReadOrWrite);
                coreDB.ChangeTracker.AutoDetectChangesEnabled = true;

                // Сносим кеш (статистика за час)
                memoryCache.Remove(KeyToMemoryCache.IspNumberOfRequestToHour(TimeIspNumberOfRequestDay));

                // Раз в час
                GC.Collect(GC.MaxGeneration);
            }
            #endregion

            #region Очистка баз + перенос NumberOfRequestDay в NumberOfRequestMonth
            if (memoryCache.TryGetValue("CronIspClearDB", out DateTime CronIspClearDB))
            {
                // Если дата отличается от текущей
                if (CronIspClearDB.Day != DateTime.Now.Day)
                {
                    SqlToMode.SetMode(SqlMode.Read);

                    // Обновляем кеш
                    memoryCache.Set("CronIspClearDB", DateTime.Now);

                    #region Очищаем NumberOfRequestMonth
                    foreach (var item in coreDB.RequestsFilter_NumberOfRequestMonth.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_NumberOfRequestMonth), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals200
                    foreach (var item in coreDB.RequestsFilter_Jurnals200.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals200), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals303
                    foreach (var item in coreDB.RequestsFilter_Jurnals303.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals303), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals403
                    foreach (var item in coreDB.RequestsFilter_Jurnals403.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals403), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals401
                    foreach (var item in coreDB.RequestsFilter_Jurnals401.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals401), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals2FA
                    foreach (var item in coreDB.RequestsFilter_Jurnals2FA.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals2FA), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals500
                    foreach (var item in coreDB.RequestsFilter_Jurnals500.AsNoTracking())
                    {
                        // Если записи больше 30 дней
                        if ((DateTime.Now - item.Time).TotalDays > 30)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_Jurnals500), item.Id));
                        }
                    }
                    #endregion

                    #region Переносим NumberOfRequestDay в NumberOfRequestMonth
                    // Хранимм дату и значение
                    Dictionary <int, NumberOfRequestBase> NumberOfRequestMonth = new Dictionary <int, NumberOfRequestBase>();

                    // Собираем статистику за прошлые дни
                    foreach (var item in coreDB.RequestsFilter_NumberOfRequestDay.AsNoTracking())
                    {
                        // Пропускаем статистику за сегодня
                        if (item.Time.Day == DateTime.Now.Day && item.Time.Month == DateTime.Now.Month)
                        {
                            continue;
                        }

                        #region Переносим значения в NumberOfRequestMonth
                        if (NumberOfRequestMonth.TryGetValue(item.Time.Day, out NumberOfRequestBase it))
                        {
                            it.Count200 += item.Count200;
                            it.Count303 += item.Count303;
                            it.Count403 += item.Count403;
                            it.Count401 += item.Count401;
                            it.Count500 += item.Count500;
                            it.Count2FA += item.Count2FA;
                        }
                        else
                        {
                            NumberOfRequestMonth.Add(item.Time.Day, item);
                        }
                        #endregion

                        // Удаляем значения из базы
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.RequestsFilter_NumberOfRequestDay), item.Id));
                    }

                    // Переносим временные данные с NumberOfRequestMonth в базу
                    foreach (var item in NumberOfRequestMonth)
                    {
                        // Добовляем в базу
                        coreDB.RequestsFilter_NumberOfRequestMonth.Add(new NumberOfRequestMonth()
                        {
                            Time        = item.Value.Time,
                            allRequests = item.Value.Count200 + item.Value.Count303 + item.Value.Count403 + item.Value.Count500 + item.Value.Count401 + item.Value.Count2FA,
                            Count200    = item.Value.Count200,
                            Count303    = item.Value.Count303,
                            Count401    = item.Value.Count401,
                            Count403    = item.Value.Count403,
                            Count500    = item.Value.Count500,
                            Count2FA    = item.Value.Count2FA,
                        });
                    }
                    #endregion

                    // Сохраняем базу
                    coreDB.SaveChanges();
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);

                    // Раз в день
                    GC.Collect(GC.MaxGeneration);
                }
            }
            else
            {
                // Создаем кеш задним числом
                memoryCache.Set("CronIspClearDB", DateTime.Now.AddDays(-1));
            }
            #endregion

            IsRun = false;
        }
Пример #29
0
 public Product(IServiceProvider services)
 {
     _scope = services.CreateScope();
     _db    = _scope.ServiceProvider.GetRequiredService <CoreDB>();
 }
Пример #30
0
        public static void Run(CoreDB coreDB, JsonDB jsonDB, IMemoryCache memoryCache)
        {
            if (IsRun || !jsonDB.AntiDdos.IsActive || Platform.Get != PlatformOS.Unix)
            {
                return;
            }
            IsRun = true;

            #region Переносим данные TCP/UPD с кеша в базу (за прошлый час)
            var TimeAntiDdosNumberOfRequestDay = DateTime.Now.AddHours(-1);
            if (memoryCache.TryGetValue(KeyToMemoryCache.AntiDdosNumberOfRequestDay(TimeAntiDdosNumberOfRequestDay), out NumberOfRequestDay dataLastHour))
            {
                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.Read);

                // Записываем данные в базу
                coreDB.AntiDdos_NumberOfRequestDays.Add(dataLastHour);

                // Сохраняем базу
                coreDB.SaveChanges();

                // Меняем режим доступа к SQL
                SqlToMode.SetMode(SqlMode.ReadOrWrite);

                // Сносим кеш (статистика за час)
                memoryCache.Remove(KeyToMemoryCache.AntiDdosNumberOfRequestDay(TimeAntiDdosNumberOfRequestDay));
            }
            #endregion

            #region Очистка баз + перенос NumberOfRequestDay в NumberOfRequestMonth
            if (memoryCache.TryGetValue("CronAntiDdosClearDB", out DateTime CronClearDB))
            {
                // Если дата отличается от текущей
                if (CronClearDB.Day != DateTime.Now.Day)
                {
                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.Read);

                    // Обновляем кеш
                    memoryCache.Set("CronAntiDdosClearDB", DateTime.Now);

                    #region Очищаем NumberOfRequestMonth
                    foreach (var item in coreDB.AntiDdos_NumberOfRequestMonths.AsNoTracking())
                    {
                        // Если записи больше 90 дней
                        if ((DateTime.Now - item.Time).TotalDays > 90)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.AntiDdos_NumberOfRequestMonths), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем Jurnals
                    foreach (var item in coreDB.AntiDdos_Jurnals.AsNoTracking())
                    {
                        // Если записи больше 90 дней
                        if ((DateTime.Now - item.Time).TotalDays > 90)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.AntiDdos_Jurnals), item.Id));
                        }
                    }
                    #endregion

                    #region Очищаем NumberOfRequestDay + Переносим NumberOfRequestDay в NumberOfRequestMonth
                    // Хранимм дату и значение
                    var NumberOfRequestMonth = new Dictionary <int, (DateTime time, long value, int CountBlocked)>();

                    // Собираем статистику за прошлые дни
                    foreach (var item in coreDB.AntiDdos_NumberOfRequestDays.AsNoTracking())
                    {
                        // Пропускаем статистику за сегодня
                        if (item.Time.Day == DateTime.Now.Day && item.Time.Month == DateTime.Now.Month)
                        {
                            continue;
                        }

                        #region Переносим значения в NumberOfRequestMonth
                        if (NumberOfRequestMonth.TryGetValue(item.Time.Day, out (DateTime time, long value, int CountBlocked)it))
                        {
                            NumberOfRequestMonth[item.Time.Day] = (it.time, (item.value > it.value ? item.value : it.value), (item.CountBlocked + it.CountBlocked));
                        }
                        else
                        {
                            NumberOfRequestMonth.Add(item.Time.Day, (item.Time, item.value, item.CountBlocked));
                        }
                        #endregion

                        // Удаляем значения из базы
                        coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.AntiDdos_NumberOfRequestDays), item.Id));
                    }

                    // Переносим временные данные с NumberOfRequestMonth в базу
                    foreach (var item in NumberOfRequestMonth)
                    {
                        // Добовляем в базу
                        coreDB.AntiDdos_NumberOfRequestMonths.Add(new NumberOfRequestMonth()
                        {
                            Time         = item.Value.time,
                            value        = item.Value.value,
                            CountBlocked = item.Value.CountBlocked
                        });
                    }
                    #endregion

                    // Сохраняем базу
                    coreDB.SaveChanges();

                    // Меняем режим доступа к SQL
                    SqlToMode.SetMode(SqlMode.ReadOrWrite);

                    // Раз в сутки
                    GC.Collect(GC.MaxGeneration);
                }
            }
            else
            {
                // Создаем кеш задним числом
                memoryCache.Set("CronAntiDdosClearDB", DateTime.Now.AddDays(-1));
            }
            #endregion

            #region Очистка IPTables/IP6Tables
            if (jsonDB.AntiDdos.BlockToIPtables)
            {
                Bash bash = new Bash();

                foreach (var comandTables in "iptables,ip6tables".Split(','))
                {
                    // Список IP
                    foreach (var line in bash.Run(comandTables + " -L INPUT -v --line-numbers | awk '{print $1,$2,$9,$12}'").Split('\n').Reverse())
                    {
                        // Разбираем строку
                        var gr = new Regex("^([0-9]+) ([^ ]+) [^ ]+ ISPCore_([^\n\r]+)$").Match(line).Groups;
                        if (string.IsNullOrWhiteSpace(gr[1].Value) || !DateTime.TryParse(gr[3].Value, out DateTime time))
                        {
                            continue;
                        }

                        // Если время блокировки истекло
                        if (DateTime.Now > time)
                        {
                            if (jsonDB.AntiDdos.ActiveLockMode)
                            {
                                if (gr[2].Value == "0")
                                {
                                    bash.Run($"{comandTables} -D INPUT {gr[1].Value}");
                                }
                                else
                                {
                                    bash.Run($"{comandTables} -Z INPUT {gr[1].Value}");
                                }
                            }
                            else
                            {
                                bash.Run($"{comandTables} -D INPUT {gr[1].Value}");
                            }
                        }
                    }
                }
            }
            #endregion

            IsRun = false;
        }