Exemple #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;
        }
Exemple #2
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;
        }
Exemple #3
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;
        }
Exemple #4
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;
        }
Exemple #5
0
        public static void ClearDbAndCacheToIPv4Or6()
        {
            // Время еще не настало
            if (IsRunClearDbAndCacheToIPv4Or6 || NextTimeClearDbAndCacheToIPv4Or6 > DateTime.Now)
            {
                return;
            }
            IsRunClearDbAndCacheToIPv4Or6 = true;

            // Блокируем выполнение кода на час
            NextTimeClearDbAndCacheToIPv4Or6 = DateTime.Now.AddHours(1);

            SqlToMode.SetMode(SqlMode.Read);

            // Подключаемся к базе
            using (var coreDB = Service.Get <CoreDB>())
            {
                foreach (var blockedIP in coreDB.BlockedsIP.AsNoTracking())
                {
                    if (DateTime.Now > blockedIP.BlockingTime)
                    {
                        if (blockedIP.typeBlockIP == TypeBlockIP.UserAgent)
                        {
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.BlockedsIP), blockedIP.Id));
                            UpdateCacheToUserAgent();
                        }
                        else
                        {
                            RemoveIPv4Or6(blockedIP.IP, blockedIP.typeBlockIP, blockedIP.BlockedHost);
                            coreDB.Database.ExecuteSqlCommand(ComandToSQL.Delete(nameof(coreDB.BlockedsIP), blockedIP.Id));
                        }
                    }
                    else
                    {
                        // Крон нужно запустить раньше
                        if (NextTimeClearDbAndCacheToIPv4Or6 > blockedIP.BlockingTime)
                        {
                            NextTimeClearDbAndCacheToIPv4Or6 = blockedIP.BlockingTime;
                        }
                    }
                }
            }

            // Не чаще одного раза в 20 секунд
            if (DateTime.Now.AddSeconds(20) > NextTimeClearDbAndCacheToIPv4Or6)
            {
                NextTimeClearDbAndCacheToIPv4Or6 = DateTime.Now.AddSeconds(20);
            }

            SqlToMode.SetMode(SqlMode.ReadOrWrite);
            IsRunClearDbAndCacheToIPv4Or6 = false;
        }
        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;
        }
Exemple #7
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;
        }