一个python的代理验证脚本

小锁

1. 
   
2. #!/bin/env python
   
3. 
   
4. import sys
   
5. import getopt
   
6. import threading
   
7. import string
   
8. import socket
   
9. import base64
   
10. import time
    
11. import urlparse
    
12. import struct
    
13. 
    
14. class Proxy:
    
15.         """
    
16.         Maintain the proxy and the status of it.
    
17.         """
    
18.         def __init__(self, urlStr):
    
19.                 # parse scheme
    
20.                 [self.scheme, t] = string.split(urlStr, "://")
    
21. 
    
22.                 # parse auth
    
23.                 if string.find(t, "@") == -1:
    
24.                         self.needAuth = False
    
25.                 else:
    
26.                         [auth, t] = string.split(t, "@")
    
27.                         self.needAuth = True
    
28.                         if string.find(auth, ":") == -1:
    
29.                                 self.needPassword = False
    
30.                                 self.username = auth
    
31.                         else:
    
32.                                 self.needPassword = True
    
33.                                 [self.username, self.password] = string.split(auth, ":")
    
34. 
    
35.                 # parse host and port
    
36.                 if string.find(t, ":") == -1:
    
37.                         self.host = t
    
38.                         self.port = 8080
    
39.                 else:
    
40.                         [self.host, t] = string.split(t, ":")
    
41.                         self.port = int(t)
    
42. 
    
43.                 # set this non validated
    
44.                 self.validated = False;
    
45. 
    
46.         def _parseHttpHeader(self, sock):
    
47.                 """
    
48.                 Parse the http response header
    
49.                 return true if success
    
50.                 """
    
51.                 retval = False
    
52.                 data = ""
    
53.                 while True:
    
54.                         data += sock.recv(1)
    
55.                         if string.find(data, "\r\n") != -1:
    
56.                                 if len(data) == 2:
    
57.                                         break
    
58.                         elif string.find(data, "\n") != -1:
    
59.                                 if len(data) == 1:
    
60.                                         break
    
61.                         else:
    
62.                                 continue
    
63.                         if string.find(data, "HTTP/1.") == 0:
    
64.                                 s = string.split(data, " ")
    
65.                                 if len(s) >= 3 and s[1] == "200":
    
66.                                         retval = True
    
67.                         data = ""
    
68. 
    
69.                 return retval
    
70. 
    
71.         def _getHttpBody(self, sock):
    
72.                 # get the body
    
73.                 while True:
    
74.                         data = sock.recv(256)
    
75.                         if data == "":
    
76.                                 break
    
77. 
    
78.         def validateHttp(self, testUrl, sock):
    
79.                 """
    
80.                 Validate the HTTP proxy with the testUrl
    
81.                 """
    
82.                 data = "GET " + testUrl + " HTTP/1.1\r\n"
    
83.                 data += "Connection: close\r\n"
    
84.                 if self.needAuth == True and self.needPassword == True:
    
85.                         auth = base64.b64encode(self.username + ":" + self.password)
    
86.                         data += "Proxy-Authorization: Basic " + auth + "\r\n";
    
87.                 data += "\r\n"
    
88.                 sock.sendall(data)
    
89. 
    
90.                 retval = self._parseHttpHeader(sock)
    
91.                 if retval:
    
92.                         self._getHttpBody(sock)
    
93. 
    
94.                 return retval
    
95. 
    
96.         def _getAddrFromUrl(self, testUrl):
    
97.                 t = urlparse.urlparse(testUrl)
    
98.                 netloc = t[1]
    
99.                 retval = []
    
100.                 if string.find(netloc, "@") != -1:
     
101.                         t = string.split(netloc, "@")
     
102.                         netloc = t[1]
     
103.                 if string.find(netloc, ":") != -1:
     
104.                         t = string.split(netloc, ":")
     
105.                         host = t[0]
     
106.                         port = int(t[1])
     
107.                 else:
     
108.                         host = netloc
     
109.                         port = 80
     
110.                 retval.append(host)
     
111.                 retval.append(port)
     
112. 
     
113.                 return retval
     
114. 
     
115.         def _getHttpPage(self, testUrl, sock):
     
116.                 [hostname, port] = self._getAddrFromUrl(testUrl)
     
117.                 t = urlparse.urlparse(testUrl)
     
118.                 if len(t) < 3 or len(t[2]) == 0:
     
119.                         path = "/"
     
120.                 else:
     
121.                         path = t[2]
     
122.                 data = "GET " + path + " HTTP/1.1\r\n"
     
123.                 data += "Host: " + hostname + "\r\n"
     
124.                 data += "Connection: close\r\n"
     
125.                 data += "\r\n"
     
126.                 sock.sendall(data)
     
127.                 if self._parseHttpHeader(sock) != True:
     
128.                         return False
     
129.                 self._getHttpBody(sock)
     
130. 
     
131.                 return True
     
132. 
     
133.         def validateHttpc(self, testUrl, sock):
     
134.                 """
     
135.                 Validate the HTTP-CONNECT proxy with the testURL
     
136.                 """
     
137.                 [hostname, port] = self._getAddrFromUrl(testUrl)
     
138.                 data = "CONNECT " + hostname + ":" + str(port) + " HTTP/1.1\r\n"
     
139.                 if self.needAuth == True and self.needPassword == True:
     
140.                         auth = base64.b64encode(self.username + ":" + self.password)
     
141.                         data += "Proxy-Authorization: Basic " + auth + "\r\n";
     
142.                 data += "\r\n"
     
143.                 sock.sendall(data)
     
144.                 if self._parseHttpHeader(sock) != True:
     
145.                         return False
     
146. 
     
147.                 return self._getHttpPage(testUrl, sock)
     
148. 
     
149.         def _recvn(self, sock, length):
     
150.                 res = ""
     
151.                 while len(res) < length:
     
152.                         ret = sock.recv(length - len(res))
     
153.                         if (len(ret) == 0):
     
154.                                 return ""
     
155.                         res += ret
     
156. 
     
157.                 return res
     
158. 
     
159.         def validateSocks4(self, testUrl, sock):
     
160.                 """
     
161.                 Validate the Socks4 proxy with testUrl
     
162.                 """
     
163.                 [hostname, port] = self._getAddrFromUrl(testUrl)
     
164.                 ip = socket.gethostbyname(hostname)
     
165.                 # send connect request
     
166.                 req = struct.pack("!BBH", 4, 1, port)
     
167.                 req = "%s%s" % (req, socket.inet_aton(ip))
     
168.                 if self.needAuth:
     
169.                         req = "%s%s\x00" % (req, self.username)
     
170.                 else:
     
171.                         req = "%s\x00" % (req)
     
172.                 sock.sendall(req)
     
173. 
     
174.                 # get and parse the response
     
175.                 res = self._recvn(sock, 8)
     
176.                 if len(res) == 0:
     
177.                         return False
     
178.                 (vn, cd) = struct.unpack("!BB", res[:2])
     
179.                 if vn != 0 or cd != 90:
     
180.                         return False
     
181. 
     
182.                 return self._getHttpPage(testUrl, sock)
     
183. 
     
184.         def validateSocks5(self, testUrl, sock):
     
185.                 """
     
186.                 Validate the Socks4 proxy with testUrl
     
187.                 """
     
188.                 # hello and authorization
     
189.                 if self.needAuth:
     
190.                         req = struct.pack("!BBBB", 5, 2, 0, 2)
     
191.                 else:
     
192.                         req = struct.pack("!BBB", 5, 1, 0)
     
193.                 sock.sendall(req)
     
194.                 res = self._recvn(sock, 2)
     
195.                 if len(res) == 0:
     
196.                         return False
     
197.                 (ver, method) = struct.unpack("!BB", res)
     
198.                 if ver != 5:
     
199.                         return False
     
200.                 if method == 2:
     
201.                         if self.needAuth != True or self.needPassword != True:
     
202.                                 return False
     
203.                         req = struct.pack("!BB", 1, len(self.username))
     
204.                         req = "%s%s%s%s" % (req, self.username, \
     
205.                                         struct.pack("!B", len(self.password)), \
     
206.                                         self.password)
     
207.                         sock.sendall(req)
     
208.                         res = self._recvn(sock, 2)
     
209.                         if len(res) == 0:
     
210.                                 return False
     
211.                         (ver, status) = struct.unpack("!BB", res)
     
212.                         if ver != 0 or status != 0:
     
213.                                 return False
     
214.                 elif method != 0:
     
215.                         return False
     
216. 
     
217.                 # connect
     
218.                 [hostname, port] = self._getAddrFromUrl(testUrl)
     
219.                 ip = socket.gethostbyname(hostname)
     
220.                 req = struct.pack("!BBBB", 5, 1, 0, 1)
     
221.                 req = "%s%s%s" % (req, socket.inet_aton(ip), struct.pack("!H", port))
     
222.                 sock.sendall(req)
     
223.                 res = self._recvn(sock, 5)
     
224.                 if len(res) == 0:
     
225.                         return False
     
226.                 (ver, rep, rsv, atyp, addrLen) = struct.unpack("!BBBBB", res)
     
227.                 if (ver != 5 or rep != 0 or rsv != 0):
     
228.                         return False
     
229.                 if atyp == 1:
     
230.                         res = self._recvn(sock, 5)
     
231.                 elif atyp == 3:
     
232.                         res = self._recvn(sock, addrLen + 2)
     
233.                 elif atyp == 4:
     
234.                         res = self._recvn(sock, 17)
     
235.                 else:
     
236.                         return False
     
237.                 if (len(res) == 0):
     
238.                         return False
     
239. 
     
240.                 return self._getHttpPage(testUrl, sock)
     
241. 
     
242.         def validate(self, testUrl):
     
243.                 """
     
244.                 Validate the proxy server, return true if successfully.
     
245.                 """
     
246.                 self.startTime = time.time()
     
247. 
     
248.                 # connect to the proxy server
     
249.                 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
     
250.                 sock.connect((self.host, self.port))
     
251.                 self.connectTime = time.time()
     
252. 
     
253.                 if self.scheme == "http":
     
254.                         retval = self.validateHttp(testUrl, sock)
     
255.                 elif self.scheme == "httpc":
     
256.                         retval = self.validateHttpc(testUrl, sock)
     
257.                 elif self.scheme == "socks4":
     
258.                         retval = self.validateSocks4(testUrl, sock)
     
259.                 elif self.scheme == "socks5":
     
260.                         retval = self.validateSocks5(testUrl, sock)
     
261.                 else:
     
262.                         retval = False
     
263. 
     
264.                 sock.close()
     
265.                 self.endTime = time.time()
     
266.                 self.validated = True
     
267. 
     
268.                 return retval
     
269. 
     
270. class ValidateThread(threading.Thread):
     
271.         def __init__(self, proxy, url, sema, lock):
     
272.                 threading.Thread.__init__(self)
     
273.                 self._proxy = proxy
     
274.                 self._sema = sema
     
275.                 self._sema.acquire()
     
276.                 self._lock = lock
     
277.                 self._url = url
     
278. 
     
279.         def __del__(self):
     
280.                 self._sema.release()
     
281. 
     
282.         def run(self):
     
283.                 if self._proxy.validate(url) == True:
     
284.                         self._lock.acquire()
     
285.                         proxy = self._proxy
     
286.                         urlStr = proxy.scheme + "://"
     
287.                         if (proxy.needAuth):
     
288.                                 urlStr += proxy.username
     
289.                                 if (proxy.needPassword):
     
290.                                         urlStr += ":" + proxy.password
     
291.                                 urlStr += "@"
     
292.                         urlStr += proxy.host + ":" + str(proxy.port)
     
293.                         print urlStr, proxy.connectTime - proxy.startTime, \
     
294.                                         proxy.endTime - proxy.connectTime, \
     
295.                                         proxy.endTime - proxy.startTime
     
296.                         self._lock.release()
     
297. 
     
298. def CreateValidateThread(proxy, url, sema, lock):
     
299.         thread = ValidateThread(proxy, url, sema, lock)
     
300.         thread.setDaemon(True)
     
301.         thread.start()
     
302. 
     
303. def showHelp(prog):
     
304.         print "valproxy 0.0.1: A proxies validating tool."
     
305.         print "Usage: %s [option]..." % prog
     
306.         print "Options:"
     
307.         print "  -h, --help             Show the help information"
     
308.         print "  -i, --input-file=file  Use the file as input instead of stdin"
     
309.         print "  -l, --test-url=url     Use the url as the test url "\
     
310.                         + "instead of www.163.com"
     
311.         print "  -n, --max-thread-num=n Set the max thread number at "\
     
312.                         + "the same time to n, default 10"
     
313. 
     
314. if __name__ == "__main__":
     
315.         maxThreadNum = 10
     
316.         lock = threading.Lock()
     
317.         url = "http://www.163.com/index.html"
     
318.         inFile = sys.stdin
     
319. 
     
320.         # parse the arguments
     
321.         try:
     
322.                 (opts, args) = getopt.getopt(sys.argv[1:], "hi:l:n:", \
     
323.                                 ["help", "input-file=", "test-url=", "max-thread-num="])
     
324.         except getopt.GetoptError:
     
325.                 showHelp(sys.argv[0])
     
326.                 sys.exit(1)
     
327.         if len(args) > 0:
     
328.                 showHelp(sys.argv[0])
     
329.                 sys.exit(1)
     
330.         for (o, a) in opts:
     
331.                 if o in ("-h", "--help"):
     
332.                         showHelp(sys.argv[0])
     
333.                         sys.exit(0)
     
334.                 elif o in ("-i", "--input-file"):
     
335.                         inFile = file(a, "r")
     
336.                 elif o in ("-l", "--test-url"):
     
337.                         url = a
     
338.                 elif o in ("-n", "--max-thread-num"):
     
339.                         maxThreadNum = int(a)
     
340.                         if (maxThreadNum <= 0):
     
341.                                 print "the argument for options n and max-thread-num must"\
     
342.                                                 + "be no less than 0"
     
343.                                 sys.exit(1)
     
344.                 else:
     
345.                         print "Unknown option: " + o
     
346.                         showHelp(sys.argv[0])
     
347.                         sys.exit(1)
     
348. 
     
349.         sema = threading.Semaphore(maxThreadNum)
     
350. 
     
351.         # validate the proxy one by one
     
352.         while True:
     
353.                 line = string.strip(inFile.readline())
     
354.                 if len(line) == 0:
     
355.                         break
     
356.                 proxy = Proxy(line)
     
357.                 CreateValidateThread(proxy, url, sema, lock)
     
358. 
     
359.         # wait until all the threads exit
     
360.         n = maxThreadNum
     
361.         while n > 0:
     
362.                 sema.acquire()
     
363.                 n -= 1
     
364.         while n < maxThreadNum:
     
365.                 sema.release()
     
366.                 n += 1
     

复制代码