Clamav杀毒软件源码分析笔记[九]

Clamav杀毒软件源码分析笔记[九]

刺猬@http://blog.csdn.net/littlehedgehog

[数据流病毒扫描]

数据流病毒扫描,听上去貌似很牛逼的称呼,其实就是一个传送数据流,接收数据流,扫描病毒而已. 貌似扫描病毒代码亦是很牛逼的代码,其实也不然,不过调用扫描病毒的引擎API函数尔. 调API调久了,自然想去看看这个API究竟怎么回事,于是乎就去看kernel代码了,想刚哥早年做游戏开发,光是调用库函数,索然无味,便一门心思要开发3D引擎. 唉,看久了API自然想去实际操作,封封API,这也就是国家要禁止黄片的原因吧...

文章开篇我就决定暂时不要研究引擎API,一来里面难度比较大,二则我目前还没准备要从事病毒工作. 这里我们也就限于调用clamlib库API而已.

先贴代码,凑齐字数

1. /* 基于流的病毒扫描,很高级的称呼么? 其实就是客户端把数据传到服务端,服务器扫描. 需要注意这里服务端是动态分配端口,也就是说我们需要把新看上的动态端口告诉客户端,这样那小子才好传麻烦过来　:*/
2. int scanstream(int odesc, unsigned long int *scanned, const struct cl_node *root, const struct cl_limits *limits, int options, const struct cfgstruct *copt)
3. {
4.     int ret, portscan = CL_DEFAULT_MAXPORTSCAN, sockfd, port = 0, acceptd;
5.     int tmpd, bread, retval, timeout, btread, min_port, max_port;
6.     long int size = 0, maxsize = 0;
7.     short bound = 0, rnd_port_first = 1;
8.     const char *virname;
9.     char buff[FILEBUFF];
10.     struct sockaddr_in server;
11.     struct hostent *he;
12.     struct cfgstruct *cpt;
13.     FILE *tmp = NULL;
14. 
    
15. 
    
16.     /* get min port 获取最小端口号*/
17.     if ((cpt = cfgopt(copt, "StreamMinPort")))
18.     {
19.         if (cpt->numarg < 1024 || cpt->numarg > 65535)
20.             min_port = 1024;
21.         else
22.             min_port = cpt->numarg;
23.     }
24.     else
25.         min_port = 1024;
26. 
    
27.     /* get max port 获取最大端口号*/
28.     if ((cpt = cfgopt(copt, "StreamMaxPort")))
29.     {
30.         if (cpt->numarg < min_port || cpt->numarg > 65535)
31.             max_port = 65535;
32.         else
33.             max_port = cpt->numarg;
34.     }
35.     else
36.         max_port = 2048;
37. 
    
38.     /* bind to a free port */
39.     while (!bound && --portscan)    //这里portscan默认是1000,也就是这里最多尝试1000个端口
40.     { 
41.         if (rnd_port_first)         //第一次分配端口   是最小端口+随机产生的数字(当然保证在正确的范围之类)
42.         {
43.             /* try a random port first */
44.             port = min_port + cli_rndnum(max_port - min_port + 1);
45.             rnd_port_first = 0;
46.         }
47.         else                        //第一次分配失败后后面就是依次尝试了
48.         {
49.             /* try the neighbor ports */
50.             if (--port < min_port)
51.                 port=max_port;
52.         }
53. 
    
54.         memset((char *) &server, 0, sizeof(server));
55.         server.sin_family = AF_INET;
56.         server.sin_port = htons(port);
57. 
    
58.         if ((cpt = cfgopt(copt, "TCPAddr")))
59.         {
60.             pthread_mutex_lock(&gh_mutex);
61.             if ((he = gethostbyname(cpt->strarg)) == 0)     //这里通常我们设置的是127.0.0.1 
62.             {
63.                 logg("!gethostbyname(%s) error: %s/n", cpt->strarg);
64.                 mdprintf(odesc, "gethostbyname(%s) ERROR/n", cpt->strarg);
65.                 pthread_mutex_unlock(&gh_mutex);
66.                 return -1;
67.             }
68.             server.sin_addr = *(struct in_addr *) he->h_addr_list[0];
69.             pthread_mutex_unlock(&gh_mutex);
70.         }
71.         else
72.             server.sin_addr.s_addr = INADDR_ANY;
73. 
    
74.         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
75.             continue;
76. 
    
77.         if (bind(sockfd, (struct sockaddr *) &server, sizeof(struct sockaddr_in)) == -1)
78.             close(sockfd);
79.         else
80.             bound = 1;
81.     }
82. 
    
83.     if ((cpt = cfgopt(copt, "ReadTimeout")))
84.         timeout = cpt->numarg;
85.     else
86.         timeout = CL_DEFAULT_SCANTIMEOUT;
87. 
    
88.     if (timeout == 0)
89.         timeout = -1;
90. 　
91.     if (!bound && !portscan)
92.     {
93.         logg("!ScanStream: Can't find any free port./n");
94.         mdprintf(odesc, "Can't find any free port. ERROR/n");
95.         close(sockfd);
96.         return -1;
97.     }
98.     else
99.     {
100.         listen(sockfd, 1);      //这里队列长度只为1
101.         mdprintf(odesc, "PORT %d/n", port);     //这里把新看上的端口告诉客户端
102.     }
103. 
     
104.     //retval如果是正数表示有多少文件描述符准备好了  --我老是忘字　-_-!
105.     switch (retval = poll_fd(sockfd, timeout))
106.     {
107.     case 0: /* timeout */
108.         mdprintf(odesc, "Accept timeout. ERROR/n");
109.         logg("!ScanStream: accept timeout./n");
110.         close(sockfd);
111.         return -1;
112.     case -1:
113.         mdprintf(odesc, "Accept poll. ERROR/n");
114.         logg("!ScanStream: accept poll failed./n");
115.         close(sockfd);
116.         return -1;
117.     }
118. 
     
119.     if ((acceptd = accept(sockfd, NULL, NULL)) == -1)
120.     {
121.         close(sockfd);
122.         mdprintf(odesc, "accept() ERROR/n");
123.         logg("!ScanStream: accept() failed./n");
124.         return -1;
125.     }
126. 
     
127.     logg("*Accepted connection on port %d, fd %d/n", port, acceptd);
128. 
     
129.     /* 下面是建立临时文件,tmpfile其实是一个库函数,真没想到*/
130.     if ((tmp = tmpfile()) == NULL)
131.     {
132.         shutdown(sockfd, 2);
133.         close(sockfd);
134.         close(acceptd);
135.         mdprintf(odesc, "tempfile() failed. ERROR/n");              
136.         logg("!ScanStream: Can't create temporary file./n");
137.         return -1;
138.     }
139.     tmpd = fileno(tmp);
140. 
     
141.     if ((cpt = cfgopt(copt, "StreamMaxLength")))
142.         maxsize = cpt->numarg;
143.     else
144.         maxsize = CL_DEFAULT_STREAMMAXLEN;
145. 
     
146. 
     
147.     btread = sizeof(buff);
148.     
149.     /* 下面主要是通过才绑定的socket获取客户端传来的文件,然后我们扫描,前面我们绑定端口忙活了一大阵子就是为了打开通道获取文件*/
150.     while ((retval = poll_fd(acceptd, timeout)) == 1)       //大于0说明有文件描述符就绪了,好,我们开始行动
151.     {
152.         bread = read(acceptd, buff, btread);                
153.         if (bread <= 0)
154.             break;
155.         size += bread;
156. 
     
157.         if (writen(tmpd, buff, bread) != bread)             //writen是作者自己编写的函数 因为这里我们需要一个函数很卖命的给我们写数据,可以说了往死里写了
158.         {
159.             shutdown(sockfd, 2);
160.             close(sockfd);
161.             close(acceptd);
162.             mdprintf(odesc, "Temporary file -> write ERROR/n");
163.             logg("!ScanStream: Can't write to temporary file./n");
164.             if (tmp)
165.                 fclose(tmp);
166.             return -1;
167.         }
168. 
     
169.         if (maxsize && (size + btread >= maxsize))      //tmp文件我们默认10M
170.         {
171.             btread = (maxsize - size); /* only read up to max 要保证不能超过文件最大值*/
172. 
     
173.             if (btread <= 0)
174.             {
175.                 logg("^ScanStream: Size limit reached ( max: %d)/n", maxsize);
176.                 break; /* Scan what we have */
177.             }
178.         }
179.     }
180. 
     
181.     switch (retval)
182.     {
183.     case 0: /* timeout */
184.         mdprintf(odesc, "read timeout ERROR/n");
185.         logg("!ScanStream: read timeout./n");
186.     case -1:
187.         mdprintf(odesc, "read poll ERROR/n");
188.         logg("!ScanStream: read poll failed./n");
189.     }
190. 
     
191.     lseek(tmpd, 0, SEEK_SET);
192.     ret = cl_scandesc(tmpd, &virname, scanned, root, limits, options);
193.     if (tmp)
194.         fclose(tmp);
195. 
     
196.     close(acceptd);
197.     close(sockfd);
198. 
     
199.     if (ret == CL_VIRUS)        　//有毒　注意这里odesc是我们和客户端通信的唯一通道
200.     {
201.         mdprintf(odesc, "stream: %s FOUND/n", virname);
202.         logg("stream: %s FOUND/n", virname);
203.         virusaction("stream", virname, copt);
204.     }
205.     else if (ret != CL_CLEAN)       //无毒又不是干净的,表明出错了
206.     {
207.         mdprintf(odesc, "stream: %s ERROR/n", cl_strerror(ret));
208.         logg("stream: %s ERROR/n", cl_strerror(ret));
209.     }
210.     else
211.     {
212.         mdprintf(odesc, "stream: OK/n");
213.         if (logok)
214.             logg("stream: OK/n");
215.     }
216. 
     
217.     return ret;
218. }

scanstream 的功能就是: 分配临时端口─────从临时端口上读取客户端的数据流（Y的，就是病毒嫌疑文件）──────扫描病毒──────结果反馈给客户端。 很清晰很明了的过程,不过要明白, 我们分配临时端口,只是为了获取数据流,传完文件就关闭,其它的一切与客户端的通信都建立在我们的老端口上.比如后面我们通知客户端小心,有毒,我们就用的是 mdprintf(odesc,  "stream: %s FOUND/n" , virname);    

写这篇文章的时候,想起一个问题,INADDR_ANY,用这个代表什么? 网上断章取义的拿来一段博文:

INADDR_ANY就是指定地址为0.0.0.0的地址,这个地址事实上表示不确定地址,或“所有地址”、“任意地址”。 一般来说，在各个系统中均定义成为0值。

例如MontiVista Linux中在/usr/include/netinet/in.h定义为：

/* Address to accept any incoming messages.  */
#define INADDR_ANY              ((in_addr_t) 0x00000000)

一般情况下，如果你要建立网络服务器应用程序，则你要通知服务器操作系统：请在某地址 xxx.xxx.xxx.xxx上的某端口 yyyy上进行侦听，并且把侦听到的数据包发送给我。这个过程，你是通过bind（）系统调用完成的。——也就是说，你的程序要绑定服务器的某地址，或者 说：把服务器的某地址上的某端口占为已用。服务器操作系统可以给你这个指定的地址，也可以不给你。
如果你的服务器有多个网卡（每个网卡上有不同的 IP地址），而你的服务（不管是在udp端口上侦听，还是在tcp端口上侦听），出于某种原因：可能是你的服务器操作系统可能随时增减IP地址，也有可能 是为了省去确定服务器上有什么网络端口（网卡）的麻烦 —— 可以要在调用bind()的时候，告诉操作系统：“我需要在 yyyy 端口上侦听，所以发送到服务器的这个端口，不管是哪个网卡/哪个IP地址接收到的数据，都是我处理的。”

其实关于病毒command的这系列代码最好紧贴着客户端代码进行,看了服务端接收信息,我们打破书上限制,直接来看客户端.