Размещено на http://www.allbest.ru/

ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ АВТОНОМНОЕ

ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ

ВЫСШЕГО ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ

«НАЦИОНАЛЬНЫЙ ИССЛЕДОВАТЕЛЬСКИЙ УНИВЕРСИТЕТ

«ВЫСШАЯ ШКОЛА ЭКОНОМИКИ»

Московский институт электроники и математики

Выпускная квалификационная работа

по направлению “09.03.03” “Прикладная информатика” студента образовательной программы бакалавриата “Прикладная Информатика”

“Оптимизация интервалов между плановыми переустановками операционной системы в локальной сети”

Рецензент: доцент, к.т.н А.Б. Лось

Студент: А.В. Кузьмин

Руководитель: Ю.Б. Гришунина

Москва

2017 г.

Аннотация

Работа посвящена исследованию эпидемической модели с точками регенерации. Для нахождения оптимального периода регенерации была изучена зависимость среднего удельного дохода от периодичности плановых переустановок ОС. Для этого выписана и решена в терминах преобразования Лапласа система интегральных уравнений относительно условных математических ожиданий дохода до начала переустановки при условии старта из различных состояний сети. С помощью программы MATLAB численно найдено обратное преобразование Лапласа от полученного решения. Кроме того, было произведено имитационное моделирование рассматриваемой системы. По полученных данным с помощью статистических методов получена оценка для оптимального периода между плановыми переустановками ОС.

Оглавление

• Введение
• 1. Обзор проблематики и постановка задачи
• 1.1 Обзор научных работ
• 1.2 Описание модели
• 2. Описание решения
• 2.1 Рассмотрение модели с точки зрения теории надёжности
• 2.2 Вычисление математического ожидания дохода от функционирования сети
• 2.3 Решение системы интегральных уравнений в терминах преобразования Лапласа
• 2.4 Обоснование существования обратного преобразования Лапласа от результата
• 2.5 Численное нахождение обратного преобразования Лапласа
• 3. Имитационное моделирование исследуемой системы
• 3.1 Описание модели
• 3.2 Реализация имитационной модели
• 3.3 Пример работы имитационной модели
• Использованная литература
• Приложения

Введение

В последнее время распространение компьютерных вирусов стало серьёзной проблемой для людей во всех сферах общества. Изначально, в 1980ых годах, когда они появились, вирусы распространялись медленно и могли наносить только небольшой ущерб. Однако с течением времени вредоносные программы развивались вместе с развитием самих компьютеров. И теперь, имея более сложный программный код и высокую скорость распространения, вирусы могут причинить серьёзный ущерб, как обычным пользователям, так и крупным корпорациям. Не смотря на то, что современные антивирусные программы, основанные в основном на методе сравнения сигнатур вирусов, идут в ногу с развитием и усложнением вредоносных программ, неизвестно, смогут ли они эффективно противостоять вирусам, если их скорость распространения будет и дальше возрастать. Так уже в январе 2003 года червь SQL Slammer заразил более 90% от всех уязвимых компьютеров менее чем за 10 минут.

А с учётом того, что пропускная способность сетей Internet только растёт, скорость распространения и заражения будет только увеличиваться в будущем. Существует два подхода для изучения и борьбы с вирусами: макроскопический и микроскопический. Вторым являются уже привычные антивирусные программы, которые, по аналогии с биологией, можно сравнить с одиночными вакцинами против болезней. Макроскопический же подход стремится к тому, чтобы предсказать долгосрочное поведение вирусов.

Основной проблемой в оценке эффективности работы антивирусных или эпидемиологических систем является то, что для них сложно подобрать контрольную группу. Она должна будет состоять из множества машин, которые можно найти, разве что в крупных компаниях. А, как известно, мало компаний захотят отключить проверенные антивирусные программы для проверки работоспособности новой системы. Из-за этого большинство исследователей в данной области занимаются в основном моделированием распространения вирусов. Поэтому имеет смысл аналитическое решение предложенных систем, и дальнейшая проверка полученных результатов с помощью моделирования. В качестве исследуемой была выбрана SIT (Susceptible, Infected, on Treatment) модель. Она является небольшим усложнением SIS модели, с добавлением третьего состояния и точек регенерации, что позволяет найти аналитическое решение.

Модель описывается в терминах теории надёжности. Далее при помощи преобразования Лапласа находится непосредственное решение, которое после этого сравнивается с результатами имитационного моделирования. В отличие от других работ в области эпидемиологических моделей, моделирование в которых происходило с использованием специального модуля программы MATLAB, в данной работе имитационное моделирование реализовано простыми программными средствами, с использованием среды разработки Microsoft Visual Studio и языка программирования C++. В первой главе будут рассмотрены работы и результаты работ других исследователей, проведена их систематизация и анализ. Во второй главе подробно описаны методы, используемые при решении поставленной задачи аналитическим способом. В третьей главе разобрано имитационное моделирование предложенной системы. В заключении будут кратно описаны основные результаты работы, их новизна и значимость.

1. Обзор проблематики и постановка задачи

1.1 Обзор научных работ

Одно из основных направлений в эпидемиологии - это построение моделей распространения компьютерных вирусов. Исследователи пытаются понять, объяснить и предсказать поведение вредоносных программ. На данный момент существует множество разных моделей, различающихся по сложности процессов, которые они описывают. Сравнение некоторых из них приведено ниже.

Первая и самая простая модель описана в статье Kim J. et al. [1]. Компьютеры в данной модели могут находиться в двух состояниях: восприимчивые к вирусам (susceptible) и заражённые (infected). Отсюда и название SIS - модель. В начале работы системы заражён только один компьютер, который может распространить вирус на остальные, с некоторой интенсивностью. Заражённые компьютер излечиваются с другим показателем интенсивности и вновь становятся восприимчивыми. Так как в данной модели не присутствует контролируемое лечение, то есть компьютеры излечиваются самостоятельно, то важно знать количество заражённых компьютеров при . Согласно результатам авторов статьи, это значение равно , где - количество заражённых компьютеров при , - общее число компьютеров, - отношение интенсивности лечения к интенсивности заражения. Таким образом не все компьютеры будут заражены одновременно. Кроме того в статье описана версия SIS модели с использованием фильтрации, которая выполняет роль контролируемого лечения. Несколько заражённых компьютеров подвергаются дополнительному лечению, что увеличивает задержки в работе сети, однако и повышает вероятность выздоровления. Kim J., Radhakrishnan S., Dhall S. показали, что введение подобного лечения снижает уровень заражения, а так же может предотвратить распространение вирусов.

Две вышеописанные модели могут быть расширены до модели SIR или модели Кермака и МакКендрика (Kermack and McKendrick SIR model) упомянутой в статье [2]. Основным отличием от предыдущих является наличие третьего состояния, в котором может находиться компьютер - Removed. В это состояние попадают компьютеры, которые прошли лечение от вируса. Данная модель не предполагает выхода из этого состояния поэтому её сложно использовать для моделирования реальных систем. Для этой цели была введена возможность выхода из состояния Removed, а также новое состояние Antidotal, котором компьютер получает иммунитет к определённому типу вируса. В итоге получилась модель SAIR, разобранная в статье [3] и ранее написанной статье тех же авторов [2]. Были добавлены три новых показателя интенсивности: , для перехода соответственно из состояния R в S, из A в I и из S в A. Последний обусловлен тем, что появляется новый вид вируса, от которого у компьютера нет защиты. Однако для того, чтобы использовать SAIR модель для реальных данных приходится не учитывать компоненту R. Объясняется это тем, что не выгодно убирать из популяции компьютеры, которые излечились от вируса и, следовательно, получили к нему иммунитет. Для большего соответствия реальным данным авторы предложили ввести новое состояние компьютера - Contaminated, в котором он является заражённым, однако не подаёт никаких симптомов заражения. Симуляция поведения вирусов на основе данной модели показала хорошие результаты для некоторых реальных заражений, таких как worm_netsky_p и pyw_dashbar_300.

В статье Zhang X. al. [4] описана U-SLIR модель, которая является модификацией SLIR модели (Susceptible-Latent-Infected-Recovered), с добавлением вероятности, что пользователь может установить антивирусное программное обеспечение на незаражённый компьютер или как приводится в статье - user awareness. Сама по себе модель SLIR является моделью рассмотренной ранее - SAIC. Здесь компонента Latent соответствует Contaminated и отвечает за компьютеры, заражённые вирусом, который себя не проявляет. Компонента Recovered соответствует Antidotal - компьютеры имеющие иммунитет к определённому типу вируса. Авторы смогли установить условие стабильности равновесных состояний без заражённых компьютеров и с ними, или иначе Virus-Free and Endemic Equilibrium. Компьютерное моделирование подтвердило эти результаты.

Другая модификация SIR модели представлена в статье Williamson M., Leveille J. [5]. PSIDR (Progressive Susceptible Infectious Detected Removed) основа на идее о том, что вирус распространяется в два этапа, сначала без помех, как только создатель выпустил его на свободу, а потом с учётом того, что антивирусные программы уже могут его обнаружить. В последнем случае заражённые компьютеры отключаются от сети и очищаются, а незаражённые получают иммунитет к вирусу. В статье представлены результаты моделирования с разным показателем задержки р, который отвечает за время, требуемое, чтобы установить сигнатуру вируса и научиться бороться с ним.

Ещё одним направлением в развитии эпидемиологии, описанным в статье [6], стало введение активной защиты. Основным её достоинством является то, что компьютер, на котором обнаружили вирус, может быть сразу же изолирован. Это может помочь антивирусным программам сравняться по скорости работы с распространением вируса. Для вредоносных программ с неизвестными сигнатурами невозможно сразу достоверно определить заражён компьютер или нет, поэтому приходится полагаться только на аномалии в работе, следовательно, существует вероятность ложной тревоги. И если она будет высока, то много здоровых компьютеров будет находиться под карантином без подключения к интернету. Из-за этого внедрение данной технологии затруднено. Для изучения её работы люди исследуют эффективность карантина при реальных эпидемиях болезней. Выяснилось, что для быстро распространяющихся вирусов, несмотря на то, что защитная система реагирует за считанные доли секунды, и все возможные угрозы изолируются, из-за человеческого фактора невозможно успеть проверить все компьютеры, находящиеся на карантине, что приводит к сильному замедлению работы системы. Для решения этой проблемы используют режим мягкого карантина, при котором изолированный аппарат вновь подключается к основной группе, если он провёл в карантине T времени, даже если он не был осмотрен вручную. Авторы показали, что, не смотря на то, что вирус будет распространяться согласно традиционным эпидемиологическим моделям, используя метод динамического карантина, можно добиться замедления скорости распространения и повысить порог эпидемии.

1.2 Описание модели

компьютерный вирус операционный есть

С развитием моделей в эпидемиологии качество описания распространения вирусов улучшалось, однако все результаты были основы только на имитационном моделировании. В качестве исследуемой сети для ВКР было принято решение выбрать модель, для которой будет возможно найти оптимальное управление аналитическими средствами. Для этого было выбрана система, являющаяся небольшим усложнением стандартной SIS модели.

Рис. 1 Схема используемой модели

Компьютер может быть в одном из трёх состояний: S (susceptible) - подвержен заражению, I (infected) - заражён, T (on treatment) - на лечении. Из состояния S компьютер можно перейти в I заразившись извне с интенсивностью л, либо от другого, уже заражённого, компьютера с интенсивностью б. Из состояния I компьютер отправляется на лечение в состояние T с интенсивностью в. Далее, с интенсивностью г, компьютер может покинуть состояние T и с вероятностью P излечиться и перейти в состояние S. А с вероятностью остаться заражённым и перейти в состояние I. Для того чтобы можно было получить аналитическое решение, была взята система, описываемая с точки зрения регенерирующих процессов и теории массового обслуживания. Некоторые решения подобных задач описаны в книге [7]. В системе присутствуют плановые переустановки системы, моменты окончания переустановок являются точками регенерации. В качестве параметра оптимизации используется доход от работы компьютера в единицу времени. Каждый работающий компьютер приносит доход в единицу времени. Когда происходит заражение, то появляется скрытый ущерб в в единицу времени, таким образом, общий доход компьютера становится равен . Если компьютер находится на лечении, то дохода он не приносит. Когда начинается переустановка системы, компьютеры так же не приносят доход, более того система несёт потери в в единицу времени. Кроме того переустановка системы, означает и обновление всех её компонент, соответственно обновляется и антивирус. - стоимость обновления защитных программ с учётом установки. В итоге задачей является оптимизация интервалов между плановыми переустановками, с учётом максимизации дохода. Итак:

· На сегодняшний момент эпидемиология получила широкое развитие из-за глобального распространения вирусов. Изучаемые модели усложняются с каждым годом и помогают моделировать поведение вредоносных программ с большой точностью.

· Так как все результаты основаны только на моделировании, то в качестве исследуемой задачи была взята система, описывающая регенерирующий процесс, решение которой уже найдено.

2. Описание решения

2.1 Рассмотрение модели с точки зрения теории надёжности

Как уже отмечалось ранее, в работе будет рассматриваться модель, описывающая регенерирующий процесс, точками регенерации которого являются плановые переустановки операционной системы в локальной сети, состоящей из двух компьютеров подключённых к сети интернет. Изменения состояний компьютеров описаны на схеме на рис.1, где л - интенсивность заражения извне, б - интенсивность передачи от одного компьютера к другому, в - интенсивность обращения к базе обновлений, г - интенсивность установки обновлений, - доход в единицу времени от функционирования здорового компьютера, - скрытый ущерб в единицу времени от заражения компьютера, - стоимость переустановки в единицу времени, - стоимость установки новой версии антивируса, T - длительность плановой переустановки, - вероятность того, что после установки обновлений компьютер выздоровеет. Решение о моменте начала плановой переустановки ОС принимается в моменты обновления сети (то есть окончания очередной переустановки). Y - время до плановой переустановки ОС. Обозначим функцию распределения Y как G(y), тогда

По формуле для математического ожидания:

Так как Y не может принимать отрицательные значения, то формула для математического ожидания примет вид:

Пусть Z - период регенерации, а - математическое ожидание дохода на интервале . Обозначим средний удельный доход в единицу времени за , тогда согласно известной формуле:

Выразим и . Математическое ожидание периода регенерации - это время до переустановки системы и длительность самой переустановки:

Подставив выражение (1) получаем:

Пусть - математическое ожидание дохода от функционирования сети за время , тогда



Теперь сформулируем задачу оптимизации:

Где - множество функций распределения:

Перепишем выражение (5) с учётом (3) и (4):

G(x) является вероятностной мерой, соответственно

где - константа.

С учётом выражения (7) можно переписать (6) как:

После замены переменных, (8) можно переписать как:

Решение задачи (5) приведено в книге [7] и основано на двух следующих утверждениях:

Утв. 1. Функционал является дробно-линейный относительно функции Это показано в выражении (9).

Утв. 2. Оптимальная стратегия может определяться в классе детерминированных стратегий, т.е.

При этом оптимальная периодичность определяется как точка максимума функции

Где (11) получено из (6) при подстановке (10).

2.2 Вычисление математического ожидания дохода от функционирования сети

Зададим формальное описание состояния системы:

где - число заражённых компьютеров в момент времени t, - число здоровых компьютеров на лечении в момент времени t, - число заражённых компьютеров на лечении в момент времени t. Предположим, что в начальный момент времени сеть находится в состоянии (0,0,0). Обозначим - условное математическое ожидание дохода системы до начала переустановки ОС при условии, что процесс стартует из состояния и время, оставшееся до плановой переустановки, равно x. Тогда . Для того чтобы найти выражение для составим систему интегральных уравнений относительно :

,

и

Согласно формуле полного математического ожидания:

Получена интегральная система из десяти уравнений с десятью переменными .

2.3 Решение системы интегральных уравнений в терминах преобразования Лапласа

Опр.1. Пусть даны две функции и , определённые в пространстве , тогда свёрткой называет интеграл вида

Уравнение полученной системы можно в общем случае записать как:

Пользуясь свойством интегрирования суммы выражение (15) можно привести к виду:



где - первообразная функция от . Заметим, что интегральная часть выражения является свёрткой. Таким образом, получена система из десяти интегральных уравнений типа свёртки.

Интеграл от комплексного переменного p называется Преобразованием Лапласа. Функцию называют изображением, а - оригиналом.

Используемые свойства преобразования Лапласа:

· Линейность

,

и .

· Свойство свёртки

Таким образом, выражение (16) при применении преобразования Лапласа перейдёт в выражение

здесь - являются изображениями соответственно.

Заметим, что только функция содержит неизвестную величину или несколько, общий вид которых можно записать как , причём .

В итоге, после применения к выражению (16) преобразования Лапласа система интегральных уравнений переходит в систему линейных уравнений, с десятью неизвестными.

Для её получения нужно получить несколько вспомогательных формул.

При применении выражений (18)-(21) к полученной ранее системе интегральных уравнений, получаем:

,

Решение данной системы было найдено с помощью пакета прикладных программ MATLAB.

2.4 Обоснование существования обратного преобразования Лапласа от результата

В силу постановки задачи, для решения требуется только одна переменная . Так как система уравнений является линейной, то её решение является дробно-рациональной функцией, т.е. имеет вид



Где и являются многочленами. Полученное значение является изображением, оригинал которого нужно найти. Для этого нужно к применить обратное преобразование Лапласа:

Для дробно-рациональных функций подсчёт данного интеграла можно заменить на нахождение вычетов по полюсам функции .

Опр.2 Точка a называется изолированной особой точкой функции , если существует окрестность , в которой однозначная функция аналитична.

Опр.3 Изолированная особая точка a называется полюсомфункции , если ;

Опр.4 Пусть a - изолированная особая точка функции . Значение интеграла

называется вычетом функции относительно особой точки a. Здесь C - замкнутый контур, целиком лежащий в окрестности точки a, где - аналитична, кроме точки a.

Далее потребуется формула, для непосредственного вычисления вычета для полюса порядка для функции :

Таким образом, выражение для можно записать как:

где i - порядковый номер полюса.

Из выражений (25) и (26) можно сделать вывод о том, что обратное преобразование Лапласа от существует и может быть найдено аналитически.

2.5 Численное нахождение обратного преобразования Лапласа

Полученное решение системы является слишком громоздким (порядка 100 страниц) для того, чтобы вычислить обратное преобразование Лапласа. Однако при подстановке числовых значений коэффициентов его посчитать удалось. Были использованы: Единицей измерения времени выбран месяц, таким образом, значения соответствующих интенсивностей вычисляются в разах в месяц.

Результат данного вычисления так же получился громоздким, и поэтому вычислить искомую величину исходя из максимума не удалось. Программа в среде MATLAB приведена в приложении 1.2.3. Имитационное моделирование исследуемой системы

3.1 Описание модели

Смысл имитационного моделирования состоит в том, чтобы повторить процессы точно так же, как бы они проходили в действительности. Наиболее часто подобные модели используют в том случае, когда не разработаны методы аналитического решения.

Основной идеей реализации служит временная линяя, которая имитирует временной промежуток, в котором функционирует система. Все происходящие события выстраиваются в очередь на этой линии. И когда наступает время самого раннего из них, система переходит в соответствующее состояние. В системе присутствует два компьютера, у каждого из которых есть время заражения, время отправки на лечение и время выхода с лечения. Так же известно, заражён ли компьютер или нет. Показатели времени генерируются аппаратными средствами и имеют экспоненциальное распределение с соответствующими параметрами. Экспоненциальное распределение получается из стандартного непрерывного равномерного распределения согласно теории математического моделирования с помощью обратного преобразования.

где - равномерного, - искомая выборка экспоненциального распределения с параметром Когда проходит времени начинается плановая переустановка, которая длится и стоит в единицу времени, а так же за установку нового программного обеспечения. Кроме того, после окончания переустановки, все временные параметры моделируются заново.

3.2 Реализация имитационной модели

Ниже будет приведено описание реализации модели, включая архитектуру класса и используемые функции. Код программы приведён в приложении 1.1.

Программа содержит один класс - Computer, служащий для описания компьютеров в системе. Он содержит следующие поля:

· ID - идентификатор компьютера, тип int

· inf_time - время до заражения, тип double

· cure_start - время до начала решения, тип double

· cure_end - время до окончания решения, тип double

· sec_inf_time - время до заражения извне, тип double. Используется в случае, если компьютер заразится от другого компьютера раньше, чем извне. В этом случае время заражения извне сохраняется в это поле

· is_infected - заражён компьютер или нет, тип bool

· is_on_cure - находится компьютер на лечении или нет, тип bool

Класс содержит один метод printcomp, который выводит информацию о компьютере.

Из-за большого объёма, код функций не будет приведён, вместо этого будет показана их структура на алгоритмическом языке.

Алгоритм работы основан на нахождении следующего в очереди события и соответственное изменение параметров. Сначала выбирается компьютер, с которым произойдёт следующее событие. Этим занимается функция choose_comp. Ей на вход подаются два объекта класса компьютер, возвращаемого значения функция не имеет.

Choose_comp:

ЕСЛИ inf_time < cure_start

ЕСЛИ inf_time < cure_end

min = inf_time

ИНАЧЕ min =cure_end

ИНАЧЕ ЕСЛИ cure_start<cure_end

min = cure_start

ИНАЧЕ min = cure_end

Данный алгоритм повторяется для двух компьютеров, после чего переменные min1 и min2 сравниваются, и выбирается соответствующий компьютер. Далее, если оставшееся время до переустановки меньше, чем найденный минимум, то начинается переустановка. Иначе вызывается функция следующего события, аргументом которой является компьютер соответствующий происходящему событию.

При начале переустановки вызывается функция pereustanovka. У неё ни нет входных значений, ни выходных.

pereustanovka:

time += T0 + T // шаг времени

profit += (profit1+profit2)*T0 // profit1 и profit2 - доход в единицу времени

newcomputer1

newcomputer2 // обновление параметров для компьютеров

T0 = constT0 // оставшееся время до переустановки = интервалу переустановки

При наступлении следующего события, вызывается функция new_state, которая его обрабатывает. Ей на вход подаётся объект класса Computer, выбранный в функции choose_comp. Выхода у функции нет.

new_state:

// создаём объект класса Computer, который является вторым компьютером

Computer secondcomp

Choose state // в зависимости от события работают разные части функции

INFECTION:

time+=inf_time

profit=(profit1+profit2)*inf_time

// вспомогательная функция, которая уменьшает все временные показатели на inf_time, моделируя то, что прошло inf_time времени.

change_time (inf_time, comp1, comp2)

inf_time = 0 // произошло заражение, поэтому все временные показатели, связан-

sec_inf_time = 0 // ные с ним, зануляются

is_infected = 1 // компьютер теперь заражён

// генерируется время передачи вируса другому компьютеру

new_inf_time =

//новое время сравнивается со старым временем заражения.

ЕСЛИ secondcomp.inf_time >newtime

secondcomp_sec_inf_time = secondcomp.inf_time

secondcomp.inf_time =new_inf_time

START OF CURE:

time += cure_start

profit += (profit1+profit2)*cure_start

change_time(cure_start,comp1,comp2)

cure_start = 0

is_on_cure =1

inf_time = 0

sec_inf_time = 0

cure_end = // генерируется время выхода с лечения

// Если другой компьютер мог бы заразиться от первого раньше, то его время заражения меняется на время заражения извне

ЕСЛИ is_infected == 1

ЕСЛИ secondcomp.sec_inf_time != 0

secondcomp.inf_time = secondcomp.sec_inf_time

secondcomp.sec_inf_time = 0

END OF CURE:

time += cure_end

profit += (profit1+profit2)*cure_end

change_time(cure_end,comp1,comp2)

cure_end=0

is_on_cure=0

cure_start =

//Если компьютер был заражён, то при выходе с лечения компьютер с вероятностью излечивается, а с вероятностью - нет.

ЕСЛИ is_infected == 1

P_0 = rand/randMax

// Вылечивается

ЕСЛИ P_0 <= P

is_infected =0

inf_time =

// Так же этот компьютер может заразиться от другого, если тот заражён

ЕСЛИ secondcomp.is_infected == 1

newtime =

ЕСЛИ newtime < inf_time

sec_inf_time=inf_time

inf_time = newtime

//Компьютер не излечился, а следовательно может заразить другой компьютер, если тот здоров

ИНАЧЕ

ЕСЛИ secondcomp.is_infected == 0

newtime =

ЕСЛИ newtime < secondcomp.inf_time

secondcomp.sec_inf_time = secondcomp.inf_time

secondcomp.inf_time = newtime

// Если компьютер был здоров до начала лечения

ИНАЧЕ

inf_time =

ЕСЛИ secondcomp.is_infected == 1

newtime =

ЕСЛИ newtime < inf_time

sec_inf_time=inf_time

inf_time = newtime

Приведём схему функции change_time. На вход подаются три параметра: время dtime, которое прошло с момент последнего события и два объекта класса Computer. Выходных параметров у функции нет.

Для каждого из двух компьютеров временные параметры изменяются на время, поданное в функцию:

ЕСЛИ comp.inf_time != 0

comp.inf_time -= dtime

ЕСЛИ comp.cure_start != 0

comp.cure_start -= dtime

ЕСЛИ comp.cure_end != 0

comp.cure_end != 0

T0 -= dtime

Таким образом, были обработаны все возможные события. После выполнения этих функций система переходит в новое состояние, от которого эти функции вызываются опять.

В основной функции main присутствует только цикл по времени с вызовом функции выбора компьютера и вывод итогового дохода

main:

ПОКА time < 200

choose_comp (comp1,comp2)

print profit

3.3 Пример работы имитационной модели

Ниже приведён полученный график зависимости , при подстановке коэффициентов

Рис. 2. График зависимости

Заключение

В предложенной работе была рассмотрена эпидемиологическая модель, с включением в неё точек регенерации. Двумя основными результатами работы стали: доказательство существования аналитического решения и имитационная модель исследуемой системы. Система была рассмотрена с точки зрения теории надёжности и регенерирующих процессов. С помощью преобразования Лапласа и элементов теории вычетов было показано, что обратное преобразование от искомой функции существует. Имитационная модель была создана средствами языка программирования C++. На её основании было определено оптимальное время до начала переустановки. В работе была описана и исследована новая система. Результаты работы могут быть использованы в дальнейшем исследовании эпидемиологических моделей с точками регенерации.

Использованная литература

[1] Kim J., Radhakrishnan S., Dhall S. (2004). Optimal control of treatment costs for internet worm. Submitted to Worm. School of Computer Science, University of Oklahoma, Norman, Oklahoma, USA

[2] Piqueira J., Vasconcelos A., Gabriel C., Araujo V. (2008). Dynamic models for computer viruses. Computer & Security, 27, 355-359

[3] Piqueira J., Araujo V. (2009). A modified epidemiological model for computer viruses. Applied Mathematics and Computation, 213, 355-360

[4] Zhang X., Chen S., Lu H., Zhang F. (2011). An improved computer multi-virus propagation model with user awareness. Journal of Information & Computational Science, 8, 4301-4308

[5] Williamson M., Leveille J. (2003). An epidemiological model of virus spread and cleanup. HP Labs Bristol, Filton Road, Stoke Gifford, BS34 8QZ, UK

[6] Zou C., Gong W., Towsley D. (2003). Worm propagation modeling and analysis under dynamic quarantine defence. WORM, 03, Washington, DC, USA

[7] Каштанов В.А., Медведев А.И. Теория надёжности сложных систем. - 2-е изд., перераб. - М.: ФИЗМАТЛИТ, 2010

[8] Дубровин В.Т. Теория функций комплексного переменного (теория и практика): Учебное пособие - Казань: Казанский государственный университет, 2010

[9] Мироновский Л.А., Петрова К.Ю. Введение в MATLAB. Учебное пособие. СПбГУАП. СПБ., 2005

Приложение 1

#include <fstream>

#include <iostream>

#include "stdafx.h"

#include <cmath>

#include <ctime>

using namespace std;

double ntime = 0, profit = 0;

double L = 1, // Интенсивность заражения извне

A = 4320, // Интенсивность передачи от 1 к другому

B = 30, // Интенсивность обращения к базе обновлений

G = 21600, // Интенсивность установки обновлений

C_0 = 100, // Доход в единицу времени

C_1 = 80, // Скрытый ущерб в единицу времени

C_2 = 10, // Стоимость переустановки в единицу времени

C_3 = 20, // Стоимость обновления антивирусов

T = 1/30, // Длительность переустановки

T0 = 5, // Интервалы между плановыми переустановками системы

P = 0.8, // Вероятность того, что после установки обновлений компьютер выздоровеет

cT0 = 15; // Постоянный интервал T0

class Computer

{

public:

int id; // идентификатор

double inf_time, // время заражения

cure_start, // время отправки на лечение

cure_end, // время окончания лечения

sec_inf_time; // сохранённое время заражения извне

bool is_infected, // заражён или нет

is_on_cure; // на лечении или нет

Computer(int nid)

{

inf_time = ((-1 / L) * log((double)rand() / RAND_MAX));

cure_start = ((-1 / B) * log((double)rand() / RAND_MAX));

cure_end = -1;

sec_inf_time = -1;

is_infected = 0;

is_on_cure = 0;

id = nid;

}

void printcomp(Computer comp)

{

cout << "ID = " << comp.id <<"\nInf_time = " << comp.inf_time << "\nCure start = " << comp.cure_start << "\nCure end = " << comp.cure_end << "\nInf and on cure : " << comp.is_infected << " " << comp.is_on_cure << endl;

}

};

Computer computer1(1), computer2(2);

void choose_comp(Computer comp1, Computer comp2);

void pereustanovka();

void new_state(Computer comp);

void change_time(double dtime, Computer &comp1, Computer &comp2);

void choose_comp(Computer comp1, Computer comp2)

{

double min1, min2, min;

// Нахождение следующего события для первого компьютера

if (comp1.is_infected == 0)

{

if (comp1.is_on_cure == 0)

{

if (comp1.inf_time != -1)

{

if (comp1.inf_time < comp1.cure_start)

{

min1 = comp1.inf_time;

}

else

{

if (comp1.cure_start != -1)

{

min1 = comp1.cure_start;

}

else

{

min1 = comp1.inf_time;

}

}

}

else

{

if (comp1.cure_start != -1)

{

min1 = comp1.cure_start;

}

else

{

cout << "ERROR";

}

}

}

else

{

if (comp1.cure_end != -1)

{

min1 = comp1.cure_end;

}

else

{

cout << "ERROR";

}

}

}

else

{

if (comp1.is_on_cure == 0)

{

if (comp1.cure_start != -1)

{

min1 = comp1.cure_start;

}

else

{

cout << "ERROR";

}

}

else

{

if (comp1.cure_end != -1)

{

min1 = comp1.cure_end;

}

else

{

cout << "ERROR";

}

}

}

// Нахождение следующего события для второго компьютера

if (comp2.is_infected == 0)

{

if (comp2.is_on_cure == 0)

{

if (comp2.inf_time != -1)

{

if (comp2.inf_time < comp2.cure_start)

{

min2 = comp2.inf_time;

}

else

{

if (comp2.cure_start != -1)

{

min2 = comp2.cure_start;

}

else

{

min2 = comp2.inf_time;

}

}

}

else

{

if (comp2.cure_start != -1)

{

min2 = comp2.cure_start;

}

else

{

cout << "ERROR";

}

}

}

else

{

if (comp2.cure_end != -1)

{

min2 = comp2.cure_end;

}

else

{

cout << "ERROR";

}

}

}

else

{

if (comp2.is_on_cure == 0)

{

if (comp2.cure_start != -1)

{

min2 = comp2.cure_start;

}

else

{

cout << "ERROR";

}

}

else

{

if (comp2.cure_end != -1)

{

min2 = comp2.cure_end;

}

else

{

cout << "ERROR";

}

}

}

if ((T0 < min1) && (T0 < min2))

{

pereustanovka();

}

else

{

new_state((min1 < min2 ? comp1 : comp2));

}

}

void pereustanovka()

{

ntime = ntime + T0 + T; // шаг времени + длительность переустановки

double delta;

delta = T0;

// по табличке это зар./не зар. это на лечении/нет , прошедшее время

profit = profit + (C_0 - (C_1 * computer1.is_infected)) * (!computer1.is_on_cure)*delta + (C_0 - (C_1 * computer2.is_infected)) * (!computer2.is_on_cure)*delta;

profit = profit - C_2*T - C_3;

//Переустановка для первого

computer1.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX));

computer1.cure_start = ((-1 / B) * log((double)rand() / RAND_MAX));

computer1.cure_end = -1;

computer1.sec_inf_time = -1;

computer1.is_infected = 0;

computer1.is_on_cure = 0;

//Переустановка для второго

computer2.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX));

computer2.cure_start = ((-1 / B) * log((double)rand() / RAND_MAX));

computer2.cure_end = -1;

computer2.sec_inf_time = -1;

computer2.is_infected = 0;

computer2.is_on_cure = 0;

// Новый цикл переустановки

T0 = cT0;

}

// Изменение времени всех событий на dtime если они не dtime ( произошедшее событие) и не -1

void change_time(double dtime, Computer &comp1, Computer &comp2)

{

if ((comp1.inf_time != -1) && (comp1.inf_time != dtime))

{

comp1.inf_time = comp1.inf_time - dtime;

}

if ((comp1.cure_start != -1) && (comp1.cure_start != dtime))

{

comp1.cure_start = comp1.cure_start - dtime;

}

if ((comp1.cure_end != -1) && (comp1.cure_end != dtime))

{

comp1.cure_end = comp1.cure_end - dtime;

}

if ((comp1.sec_inf_time != -1) && (comp1.sec_inf_time != dtime))

{

comp1.sec_inf_time = comp1.sec_inf_time - dtime;

if (comp1.sec_inf_time <= 0)

{

comp1.sec_inf_time = -1;

}

}

if ((comp2.inf_time != -1) && (comp2.inf_time != dtime))

{

comp2.inf_time = comp2.inf_time - dtime;

}

if ((comp2.cure_start != -1) && (comp2.cure_start != dtime))

{

comp2.cure_start = comp2.cure_start - dtime;

}

if ((comp2.cure_end != -1) && (comp2.cure_end != dtime))

{

comp2.cure_end = comp2.cure_end - dtime;

}

if ((comp2.sec_inf_time != -1) && (comp2.sec_inf_time != dtime))

{

comp2.sec_inf_time = comp2.sec_inf_time - dtime;

if (comp2.sec_inf_time <= 0)

{

comp2.sec_inf_time = -1;

}

}

T0 = T0 - dtime;

if (T0 <= 0)

{

cout << "PEREUSTANOVKA ERROR";

}

}

void new_state(Computer comp)

{

Computer newcomp(3);

if (comp.id == computer1.id) //newcomp - второй компьютер без минимума

{

newcomp = computer2; // Comp - компьютер с минимумом

}

else

{

newcomp = computer1;

}

double min;

if ((comp.inf_time < comp.cure_start) && (comp.inf_time != -1))

{

if ((comp.inf_time < comp.cure_end) || (comp.cure_end == -1)) // Происходит заражение компьютера

{

if (comp.is_infected == 1)

{

cout << "INF ERROR";

}

ntime = ntime + comp.inf_time; // шаг времени

double delta;

delta = comp.inf_time;

// по табличке это зар./не зар. это на лечении/нет , прошедшее время

profit = profit + (C_0 - (C_1 * comp.is_infected)) * (!comp.is_on_cure)*delta + (C_0 - (C_1 * newcomp.is_infected)) * (!newcomp.is_on_cure)*delta;

change_time(delta, comp, newcomp); // Изменение других показателей времени, с учётом того, что прошло comp.inf_time времени.

comp.inf_time = -1;

comp.sec_inf_time = -1;

double newtime;

newtime = ((-1 / A) * log((double)rand() / RAND_MAX)); // сколько до заражения другого

if (newtime < newcomp.inf_time) // если второй компьютер заражается от первого раньше чем извне

{

newcomp.sec_inf_time = newcomp.inf_time; // сохраняем время заражения извне, на случай если заражающий компьютер уйдёт на лечение.

newcomp.inf_time = newtime;

}

comp.is_infected = 1;

}

else

{

// Компьютер выходит с лечения, с вероятностью P излечивается или нет

// если да, генерируем время заражения извне и время заражения от другого, если он заражён

// также генерируем время ухода на лечение

// если нет то генерируем время ухода на лечение

// и время заражения другого компьюетра если он здоров + сравниваем с прошлым значением

if (comp.is_on_cure == 0)

{

cout << "123\n\n";

cout << comp.inf_time << " " << comp.cure_start << " " << comp.cure_end << endl;

cout << "END OF CURE ERROR\n";

exit;

}

ntime = ntime + comp.cure_end; // шаг времени

double delta;

delta = comp.cure_end;

// по табличке это зар./не зар. это на лечении/нет , прошедшее время

profit = profit + (C_0 - (C_1 * comp.is_infected)) * (!comp.is_on_cure)*delta + (C_0 - (C_1 * newcomp.is_infected)) * (!newcomp.is_on_cure)*delta;

change_time(delta, comp, newcomp); // Изменение других показателей времени

comp.cure_end = -1;

comp.is_on_cure = 0;

if (comp.is_infected == 1)

{

double P_0;

P_0 = ((double)rand() / RAND_MAX);

// Излечился

if (P_0 <= P)

{

comp.is_infected = 0;

comp.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX)); //извне

if (newcomp.is_infected == 1) // от другого компьютера

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (comp.inf_time > stime)

{

comp.sec_inf_time = comp.inf_time;

comp.inf_time = stime;

}

}

}

// не излечился

else

{

if (newcomp.is_infected == 0) // заражаем другой

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (newcomp.inf_time > stime)

{

newcomp.sec_inf_time = newcomp.inf_time;

newcomp.inf_time = stime;

}

}

}

}

// Если был здоров до начала лечения

else

{

comp.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX)); //извне

if (newcomp.is_infected == 1) // от другого компьютера

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (comp.inf_time > stime)

{

comp.sec_inf_time = comp.inf_time;

comp.inf_time = stime;

}

}

}

comp.cure_start = ((-1 / B) * log((double)rand() / RAND_MAX));

}

}

else

{

if (comp.cure_start != -1)

{

if ((comp.cure_start < comp.cure_end) || (comp.cure_end == -1))

{

// Компьютер отправляется на лечение

// Время заражения обнуляется

// Генерируется время выхода из лечения

////////////////////////////////////////////////////////////////////////////////////////

// Если заражён для второго компьютера нужно изменить на прошлое время заражения извне//

////////////////////////////////////////////////////////////////////////////////////////

if (comp.is_on_cure == 1)

{

cout << "START OF CURE ERROR";

}

ntime = ntime + comp.cure_start; // шаг времени

double delta;

delta = comp.cure_start;

// по табличке это зар./не зар. это на лечении/нет , прошедшее время

profit = profit + (C_0 - (C_1 * comp.is_infected)) * (!comp.is_on_cure)*delta + (C_0 - (C_1 * newcomp.is_infected)) * (!newcomp.is_on_cure)*delta;

change_time(delta, comp, newcomp); // Изменение других показателей времени

comp.cure_start = -1;

comp.is_on_cure = 1;

comp.cure_end = ((-1 / G) * log((double)rand() / RAND_MAX));

comp.inf_time = -1;

comp.sec_inf_time = -1;

if (comp.is_infected == 1) // Второй теперь заражается извне, а не от первого

{

if (newcomp.sec_inf_time != -1)

{

newcomp.inf_time = newcomp.sec_inf_time;

newcomp.sec_inf_time = -1;

}

}

}

}

else if (comp.cure_end != -1)

{

// Компьютер выходит с лечения, с вероятностью P излечивается или нет

// если да, генерируем время заражения извне и время заражения от другого, если он заражён

// также генерируем время ухода на лечение

// если нет то генерируем время ухода на лечение

// и время заражения другого компьюетра если он здоров + сравниваем с прошлым значением

if (comp.is_on_cure == 0)

{

cout << comp.inf_time << " " << comp.cure_start << " " << comp.cure_end << endl;

cout << "END OF CURE ERROR";

}

ntime = ntime + comp.cure_end; // шаг времени

double delta;

delta = comp.cure_end;

// по табличке это зар./не зар. это на лечении/нет , прошедшее время

profit = profit + (C_0 - (C_1 * comp.is_infected)) * (!comp.is_on_cure)*delta + (C_0 - (C_1 * newcomp.is_infected)) * (!newcomp.is_on_cure)*delta;

change_time(delta, comp, newcomp); // Изменение других показателей времени

comp.cure_end = -1;

comp.is_on_cure = 0;

if (comp.is_infected == 1)

{

double P_0;

P_0 = ((double)rand() / RAND_MAX);

// Излечился

if (P_0 <= P)

{

comp.is_infected = 0;

comp.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX)); //извне

if (newcomp.is_infected == 1) // от другого компьютера

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (comp.inf_time > stime)

{

comp.sec_inf_time = comp.inf_time;

comp.inf_time = stime;

}

}

}

// не излечился

else

{

if (newcomp.is_infected == 0) // заражаем другой

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (newcomp.inf_time > stime)

{

newcomp.sec_inf_time = newcomp.inf_time;

newcomp.inf_time = stime;

}

}

}

}

// Если был здоров до начала лечения

else

{

comp.inf_time = ((-1 / L) * log((double)rand() / RAND_MAX)); //извне

if (newcomp.is_infected == 1) // от другого компьютера

{

double stime;

stime = ((-1 / A) * log((double)rand() / RAND_MAX));

if (comp.inf_time > stime)

{

comp.sec_inf_time = comp.inf_time;

comp.inf_time = stime;

}

}

}

comp.cure_start = ((-1 / B) * log((double)rand() / RAND_MAX));

}

else

{

cout << "CRITICAL ERROR 2" << endl;

}

}

if (comp.id == computer1.id)

{

computer2 = newcomp;

computer1 = comp;

}

else

{

computer1 = newcomp;

computer2 = comp;

}

}

int main()

{

srand(time(NULL));

ofstream fout("Test_T0.txt");

double maxprofit = 0;

int mT0, T0counter= 1, T0min;

T0min = 5;

double avgprofit = 0;

for (T0counter = T0min; T0counter <= 20*T0min; T0counter=T0counter+1)

{

cT0 = T0counter;

T0 = T0counter;

for (int i = 0; i < 100; i++)

{

Computer newcomputer1(1), newcomputer2(2);

computer1 = newcomputer1;

computer2 = newcomputer2;

while (ntime <= 100 * T0min)

{

choose_comp(computer1, computer2);

}

avgprofit += profit;

profit = 0;

ntime = 0;

}

cout << T0counter << endl;

avgprofit = avgprofit / 100;

if (avgprofit > maxprofit)

{

maxprofit = avgprofit;

mT0 = T0counter;

}

fout << T0counter << " " << avgprofit << endl;

avgprofit = 0;

}

cout << "Max profit = " << maxprofit << " T0 = " << mT0-T0min << endl;

return 0;

}

Код, использованный для построения графика в MATLAB.

fid=fopen('graph data.txt','r');

sizeA = [2 Inf];

A = fscanf(fid,'%f',sizeA);

B = A(1,:);

C = A(2,:);

p = polyfit(B,C,4);

x=5:1:100;

f=p(1)*x.^4 + p(2)*x.^3 + p(3)*x.^2 + p(4).*x + p(5);

plot(x,C,'+',x,f)

Приложение 2

syms x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 L A B G C0 C1 C2 C3 S P0 T T0 RO;

[x1,x2,x3,x4,x5,x6,x7,x8,x9,x10] = solve('x1=2*C0*(1/(S+2*L+2*B)^2)+4*C0*(L+B)(1/(S*(( S+2*L+2*B)^2)))+(2*B*x3+2*L*x2)*(1/(S+2*(L+B)))','x2=(2*C0-C1)*(1/(S+L+2*B+A)^2)+(2*C0-C1)*( L+2*B+A)*(1/(S*( (S+L+2*B+A)^2)))+(B*x5 + B*x4 + L*x8 + A*x8) *(1/(S+L+2*B+A))','x3=C0*(1/(S+L+B+G)^2)+C0*(L+B+G)*(1/(S*(( S+L+B+G)^2)))+ (L*x5+G*x1+B*x9)*(1/(S+L+B+G))','x4=C0*(1/(S+L+B+G)^2)+C0*( L+B+G)*(1/(S*((S+L+B+G)^2)))+(L*x6+P0*G*x1+(1-P0)*G*x2+B*x7)*(1/(S+L+B+G))','x5=(C0-C1)*(1/(S+B+G)^2)+(C0-C1)*( B+G)*(1/(S*(( S+B+G)^2)))+(B*x7+G*x2)*(1/(S+B+G))','x6=(C0-C1)*(1/(S+B+G)^2)+(C0-C1)*( B+G)*(1/(S*(( S+B+G)^2)))+(B*x10+P0*G*x2+(1-P0)*G*x8)*(1/(S+B+G))','x7=(G*x4+P0*G*x3+(1-P0)*G*x5)*(1/(S+2*G))','x8=2*(C0-C1)*(1/(S+2*B)^2)+2*(C0-C1)*( 2*B)*(1/(S*( (S+2*B)^2)))+2*B*x6*(1/(S+2*B))','x9=2*G*x3*(1/(S+2*G))','x10=(2*P0*G*x4+2*(1-P0)*G*x6)*(1/(S+2*G))');

xx1 = subs(x1, L, 1);

xx2 = subs(xx1,A,4320);

xx3=subs(xx2,B,30);

xx4=subs(xx3,G,21600);

xx5=subs(xx4,C0,100);

xx6=subs(xx5,C1,80);

xx7=subs(xx6,P0,4/5);

xx8 = ilaplace(xx7,S,T0);

RO = (xx8-C2*T-C3)/(T0+T);

RO1 = subs(RO,C2,10);

RO2= subs(RO1,C3,20);

RO3 =subs(RO2,T,1/30);

diffRO=diff(RO3,T0);

vpadiffRO = vpa(diffRO);

eqn = vpadiffRO == 0;

NS = vpasolve(eqn,T0)

syms x;

vpadiffROx = subs(vpadiffRO, T0,x);

ezplot(vpadiffROx);

Размещено на Allbest.ru

...