使用 Snort 和 PHP 构建一个小型网络防御系统

typedef struct _Alertpkt
{
u_int8_t alertmsg[ALERTMSG_LENGTH]; /* 报警消息 */
struct pcap_pkthdr pkth;
u_int32_t dlthdr;       /* datalink header offset. (ethernet, etc.. ) */
u_int32_t nethdr;       /* network header offset. (ip etc...) */
u_int32_t transhdr;     /* transport header offset (tcp/udp/icmp ..) */
u_int32_t data;
u_int32_t val;  /*指出有效的字段*/
……
Event event; /* 报警事件的相关信息 */
} Alertpkt;

typedef struct _HNInfo
{
int event_id; // 结点ID
char blockIP[16]; //阻塞主机的IP地址
time_t timestamp; // 阻塞开始时间
int blocktime; // 主机阻塞时间
char msg[500]; // 阻塞原因
char desIP[16]; // 引起报警的包的目的地址
char protocol[5]; // tcp, udp or icmp
uint16_t srcPort; // 源端口
uint16_t desPort; // 目的端口
struct _HNInfo* next; // 指向下一个结点
} HNInfo; // 队列里的结点结构

typedef struct  _HNQueue
{
struct _HNInfo  *head, *tail;
int count;
} AlertQ; // 报警队列

typedef struct AlertQ BlockQ; // 阻塞队列

int sockfd; // 监听Snort的报警消息
int btime = (1 << 29) - 1; // 默认的阻塞时间

struct _HNQueue AQ; // 报警队列
struct _HNQueue BQ; // 阻塞队列

// 线程同步所需mutex和条件变量
pthread_mutex_t AQ_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t BQ_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t AQ_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t BQ_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t BQ_timedcond = PTHREAD_COND_INITIALIZER;

pthread_t mtid; // 记录主线程ID

Int main (int argc,char** argv)
{
struct sockaddr_un snortaddr;
struct sockaddr_un bogus;
Alertpkt alert;
Packet *p = NULL;
int recv;
socklen_t len = sizeof (struct sockaddr_un);

HNInfo *cur, *node, *pivot;
pthread_t tidA, tidB;
if(argc == 2 && !strcmp(argv[1],"-D"))
daemon_init(); // 以后台方式运行
//程序初始化工作，包括AQ、BQ的初始化，建立php请求监听端口和建立php请求处理线程池。
goInit();
// 捕获用户终止或kill消息并进行清理操作
signal(SIGINT, sig_int);
signal(SIGTERM, sig_term);
// 建立维护报警队列和阻塞队列的两个线程
pthread_create(&tidA, NULL, alertHandler, NULL);
pthread_create(&tidB, NULL, blockHandler, NULL);

mtid = pthread_self(); // 记录主线程ID
// 使用UDP套接字接收Snort的报警消息
if ((sockfd = socket (AF_UNIX, SOCK_DGRAM, 0)) < 0)
{
perror ("socket");
exit (1);
}

unlink(UNSOCK_FILE);
bzero (&snortaddr, sizeof (snortaddr));
snortaddr.sun_family = AF_UNIX; // 设置为Unix域套接字
strcpy (snortaddr.sun_path, UNSOCK_FILE); // 将path设为UNSOCK_FILE

if (bind (sockfd, (struct sockaddr *) &snortaddr, sizeof (snortaddr)) < 0)
{
perror ("bind");
exit (1);
}
// 接收Snort的报警数据
while ((recv = recvfrom (sockfd, (void *) &alert, sizeof (alert),
0, (struct sockaddr *) &bogus, &len)) > 0)
{
p = ParsePacket(&alert); // 解析报警信息
if(p != NULL)
{
node = MakeNode(&alert, p);  // 建立报警信息结点
if(node != NULL)
{
PushQueue(node); // 将报警信息加入报警队列
}
free(p);
p = NULL;
}
}
exitClean(); // 清理工作
return 0;
}

HNInfo * MakeNode(Alertpkt* alert, Packet *p)
{
分配新结点node；
strcpy(node->blockIP , (char*) inet_ntoa (p->iph->ip_src)); // 解析源IP地址
strcpy(node->desIP, (char*) inet_ntoa(p->iph->ip_dst)); // 解析目的IP地址
node->timestamp = time(NULL); // 结点生成时间
node->blocktime = btime; // 阻塞时间
node->event_id = alert->event.event_id; // 事件ID号
strcpy(node->msg, alert->alertmsg); // 报警原因
// 解析报警协议及端口号
if (!(alert->val & NOPACKET_STRUCT))
if (p->iph && (p->tcph || p->udph || p->icmph))
{
switch (p->iph->ip_proto)
{
case IPPROTO_TCP:
strcpy(node->protocol, "TCP");
node->srcPort = ntohs (p->tcph->th_sport);
node->desPort = ntohs (p->tcph->th_dport);
break;
case IPPROTO_UDP:
strcpy(node->protocol, "UDP");
node->srcPort = ntohs (p->udph->uh_sport);
node->desPort = ntohs (p->udph->uh_dport);
break;
case IPPROTO_ICMP:
strcpy(node->protocol, "ICMP");
break;
}
}
return node;
}
void PushQueue(HNInfo* node)
{
pthread_mutex_lock(&AQ_mutex);
加入报警信息结点；
// 通知报警信息处理线程，有新结点加入
pthread_cond_signal(&AQ_cond);
pthread_mutex_unlock(&AQ_mutex);
}

void *alertHandler(void * vptr)
{
HNInfo* cur, *pivot, *tmp;
char cmd[200];

while(1)
{
pthread_mutex_lock(&AQ_mutex);
// 直到AQ不为空，线程被唤醒
while(AQ.count == 0)
pthread_cond_wait(&AQ_cond, &AQ_mutex);
cur = AQ.head;
while(cur != NULL)
{
// 检验BQ中是否含相同主机结点
pthread_mutex_lock(&BQ_mutex);
if(BQ.count) // BQ不为空
{
cur = PopQueue(&AQ);
if(找到相应结点)修改BQ中对应结点的值并释放cur；
else{// 结点未找到，将其添加入BQ并添加防火墙规则
结点加入BQ；
snprintf(cmd,sizeof(cmd),"/sbin/iptables -I INPUT
-s %s -j DROP",cur->blockIP);
system(cmd); // 添加防火墙规则
}
}
// BQ为空，只需添加结点、防火墙规则，并通知阻塞队列维护线程，BQ中有新结点产生
else
{
结点加入BQ并添加防火墙规则 ；
//通知阻塞队列维护线程
pthread_cond_signal(&BQ_cond);
}
pthread_mutex_unlock(&BQ_mutex);
cur = AQ.head;
}
pthread_mutex_unlock(&AQ_mutex);
}
}
// blockHandler检测阻塞主机队列，一旦某个主机阻塞时间已到，
则从阻塞队列中删除，并// 将对应的阻塞主机放行
void *blockHandler(void * vptr)
{
HNInfo* pivot, *cur;
char cmd[200];
time_t min, tmp;
while(1)
{
pthread_mutex_lock(&BQ_mutex);
while(BQ.count == 0) // 若BQ为空，线程休眠
pthread_cond_wait(&BQ_cond, &BQ_mutex);

pivot = BQ.head;
cur = BQ.head;
while(cur != NULL)
{
tmp = cur->timestamp + cur->blocktime ;
if(cur == BQ.head)min = tmp;
else min =  min > tmp ? tmp : min;

if(tmp <= time(NULL)) 时间到删除结点及防火墙规则；
else
{
pivot = cur;
cur = cur->next;
}
}
// 当肯定没有主机阻塞时间到时，线程休眠。
struct timespec ts;
ts.tv_sec = min;
ts.tv_nsec = 0;
pthread_cond_timedwait(&BQ_timedcond, &BQ_mutex, &ts);
pthread_mutex_unlock(&BQ_mutex);
}
}

int listenfd; // 处理PHP请求的监听端口

pthread_t THREADPOOL[50]; // 处理php请求的线程池
pthread_mutex_t WEB_mutex = PTHREAD_MUTEX_INITIALIZER;

webHandler线程处理来自php的请求，并对阻塞队列进行相应操作。
void* webHandler(void *vptr)
{
int connfd; // 与php通信端口
…
while(1)
{
pthread_mutex_lock(&WEB_mutex);
// 监听来自php的请求并建立通信连接
connfd = accept(listenfd,  &cliaddr, &clilen);
pthread_mutex_unlock(&WEB_mutex);
memset(buf, 0, sizeof(buf));
if((n = read(connfd, buf, sizeof(buf))) == 0)continue; // 读取php请求
if(strlen(buf) == 0)continue;
解析客户端请求；
if(查询BQ状态)
{
pthread_mutex_lock(&BQ_mutex);
读取并发送BQ信息；
pthread_mutex_unlock(&BQ_mutex);
}
else if(删除或修改BQ中某主机信息)
{
pthread_mutex_lock(&BQ_mutex);
删除或修改主机信息和防火墙规则，并返回执行结果；
pthread_mutex_unlock(&BQ_mutex);
}
else 发送出错消息；
close(connfd);
}
}

function DoQuery(&$errno)
{
$servSocket = OpenAlertSock(); // 打开通信端口
$buf = "query";
socket_write($servSocket, $buf, strlen($buf));
while ($out = socket_read($servSocket, 2048))
{
$result = $result.$out;
}
socket_close($servSocket);
解析阻塞主机信息，并将其存入数组返回。
}
function DoModify($cmd)
{
$servSocket = OpenAlertSock();
socket_write($servSocket, $cmd, strlen($cmd)); // 发送删除或修改请求
while ($out = socket_read($servSocket, 2048))
{
$result = $result.$out;
}
socket_close($servSocket);
解析操作结果并返回。
}