def run(self): # la funzione che da' le istruzioni ai vari threads
data = random._urandom(1024) # data per il pacchetto random
p = bytes(IP(dst=str(url2))/TCP(sport=RandShort(), dport=int(port))/data) # costruzione pacchetto tcp + data
current = x # per dare l'id al thread
if current < len(proxies): # se l'id del thread si puo' associare ad un proxy, usa quel proxy
proxy = proxies[current].strip().split(':')
else: # altrimenti lo prende a random
proxy = random.choice(proxies).strip().split(":")
go.wait() # aspetta che threads siano pronti
while True:
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]), int(proxy[1]), True) # comando per il proxying via SOCKS
s = socks.socksocket() # creazione socket
s.connect((str(url2),int(port))) # si connette
s.send(p) # ed invia
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # print req + counter
except: # se si verifica un errore
s.close() # intanto chiude il precedente socket non funzionante
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4, str(proxy[0]), int(proxy[1]), True) # poi prova ad utilizzare SOCKS4, magari e' questo il problema dell'errore
s = socks.socksocket() # creazione socket
s.connect((str(url2),int(port))) # connessione
s.send(p) # invio
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # print req + counter
except: # se nemmeno questo funge, allora il sock e' down
print ("Sock down. Retrying request. @", self.counter)
s.close() # chiude il socket e ricomincia ciclo
python类socksocket()的实例源码
def run(self): # la funzione che da' le istruzioni ai vari threads
data = random._urandom(1024) # data per il pacchetto random
p = bytes(IP(dst=str(url2))/UDP(dport=int(port))/data) # crea pacchetto udp classico + data
current = x # per dare l'id al thread
if current < len(proxies): # se l'id del thread si puo' associare ad un proxy, usa quel proxy
proxy = proxies[current].strip().split(':')
else: # altrimenti lo prende a random
proxy = random.choice(proxies).strip().split(":")
go.wait() # aspetta che threads siano pronti
while True:
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]), int(proxy[1]), True) # comando per il proxying con SOCKS
s = socks.socksocket() # creazione socket
s.connect((str(url2),int(port))) # connessione
s.send(p) # invio
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # req + counter
except: # se qualcosa va storto questo except chiude il socket e si collega al try sotto
s.close() # intanto chiude il precedente socket non funzionante
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4, str(proxy[0]), int(proxy[1]), True) # poi prova ad utilizzare SOCKS4, magari e' questo il problema dell'errore
s = socks.socksocket() # creazione socket
s.connect((str(url2),int(port))) # connessione
s.send(p) # invio
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # req + counter
except: # se nemmeno questo funge, allora il sock e' down
print ("Sock down. Retrying request. @", self.counter)
s.close() # chiude il socket e ricomincia ciclo
def run(self): # la funzione che da' le istruzioni ai vari threads
useragent = "User-Agent: " + random.choice(useragents) + "\r\n" # scelta proxy a caso
accept = random.choice(acceptall) # scelta accept a caso
request = get_host + useragent + accept + connection + "\r\n" # composizione final request
current = x # per dare l'id al thread
if current < len(proxies): # se l'id del thread si puo' associare ad un proxy, usa quel proxy
proxy = proxies[current].strip().split(':')
else: # altrimenti lo prende a random
proxy = random.choice(proxies).strip().split(":")
go.wait() # aspetta che threads siano pronti
while True:
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]), int(proxy[1]), True) # comando per proxarci con i socks
s = socks.socksocket() # creazione socket con pysocks
s.connect((str(url2), int(urlport))) # connessione
s.send (str.encode(request)) # invio
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # print req + counter
except: # se qualcosa va storto questo except chiude il socket e si collega al try sotto
s.close() # chiude socket
try: # il try prova a vedere se l'errore e' causato dalla tipologia di socks errata, infatti prova con SOCKS4
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4, str(proxy[0]), int(proxy[1]), True) # prova con SOCKS4
s = socks.socksocket() # creazione nuovo socket
s.connect((str(url2), int(urlport))) # connessione
s.send (str.encode(request)) # invio
print ("Request sent from " + str(proxy[0]+":"+proxy[1]) + " @", self.counter) # print req + counter
except:
print ("Sock down. Retrying request. @", self.counter)
s.close() # se nemmeno con quel try si e' riuscito a inviare niente, allora il sock e' down e chiude il socket.
def _simple_check_worker():
global _checking_lock, _checking_num, network_stat, last_check_time
time_now = time.time()
if config.PROXY_ENABLE:
socket.socket = socks.socksocket
xlog.debug("patch socks")
_checking_lock.acquire()
_checking_num += 1
_checking_lock.release()
network_ok = False
for host in ["www.microsoft.com", "www.apple.com", "code.jquery.com", "cdn.bootcss.com", "cdnjs.cloudflare.com"]:
if _check_one_host(host):
network_ok = True
break
if network_ok:
last_check_time = time.time()
report_network_ok()
xlog.debug("network is ok, cost:%d ms", 1000 * (time.time() - time_now))
else:
xlog.warn("network fail")
network_stat = "Fail"
last_check_time = time.time()
_checking_lock.acquire()
_checking_num -= 1
_checking_lock.release()
if config.PROXY_ENABLE:
socket.socket = default_socket
xlog.debug("restore socket")
def get_recv_info(domain, whois_addr, tcpCliSock):
# global _ip, _port, _mode
HOST = whois_addr
data_result = ""
PORT = 43 # ??
BUFSIZ = 1024 # ????????
ADDR = (HOST, PORT)
EOF = "\r\n"
data_send = domain + EOF
socks.setdefaultproxy(proxytype = _mode, addr = _ip, port = _port)
socket.socket = socks.socksocket
try:
tcpCliSock.connect(ADDR)
tcpCliSock.send(data_send)
except socket.error, e:
return
# if str(e).find("time out") != -1: #????
# return "ERROR -1"
# elif str(e).find("Temporary failure in name resolution") != -1:
# return "ERROR -2"
# else:
# return 'ERROR other'
while True:
try:
data_rcv = tcpCliSock.recv(BUFSIZ)
except socket.error, e:
return
if not len(data_rcv):
return data_result # ??????
data_result = data_result + data_rcv # ????????
def connect(self):
"""Connect to the host and port specified in __init__."""
# Mostly verbatim from httplib.py.
msg = "getaddrinfo returns an empty list"
for res in socket.getaddrinfo(self.host, self.port, 0,
socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
try:
if self.proxy_info and self.proxy_info.isgood():
self.sock = socks.socksocket(af, socktype, proto)
self.sock.setproxy(*self.proxy_info.astuple())
else:
self.sock = socket.socket(af, socktype, proto)
# Different from httplib: support timeouts.
if has_timeout(self.timeout):
self.sock.settimeout(self.timeout)
# End of difference from httplib.
if self.debuglevel > 0:
print "connect: (%s, %s)" % (self.host, self.port)
self.sock.connect(sa)
except socket.error, msg:
if self.debuglevel > 0:
print 'connect fail:', (self.host, self.port)
if self.sock:
self.sock.close()
self.sock = None
continue
break
if not self.sock:
raise socket.error, msg
def connect(self):
"Connect to a host on a given (SSL) port."
if self.proxy_info and self.proxy_info.isgood():
sock = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
sock.setproxy(*self.proxy_info.astuple())
else:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if has_timeout(self.timeout):
sock.settimeout(self.timeout)
sock.connect((self.host, self.port))
self.sock =_ssl_wrap_socket(sock, self.key_file, self.cert_file)
def connect( self ):
self.sock = socks.socksocket()
self.sock.setproxy( *self.proxyargs )
if isinstance( self.timeout, float ):
self.sock.settimeout( self.timeout )
self.sock.connect(( self.host, self.port ))
def create_connection(address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
def disable(cls):
cls._is_enabled = False
socket.socket = old_socket
socket.SocketType = old_SocketType
socket._socketobject = old_socket
socket.create_connection = old_create_connection
socket.gethostname = old_gethostname
socket.gethostbyname = old_gethostbyname
socket.getaddrinfo = old_getaddrinfo
socket.__dict__['socket'] = old_socket
socket.__dict__['_socketobject'] = old_socket
socket.__dict__['SocketType'] = old_SocketType
socket.__dict__['create_connection'] = old_create_connection
socket.__dict__['gethostname'] = old_gethostname
socket.__dict__['gethostbyname'] = old_gethostbyname
socket.__dict__['getaddrinfo'] = old_getaddrinfo
if socks:
socks.socksocket = old_socksocket
socks.__dict__['socksocket'] = old_socksocket
if ssl:
ssl.wrap_socket = old_ssl_wrap_socket
ssl.SSLSocket = old_sslsocket
ssl.__dict__['wrap_socket'] = old_ssl_wrap_socket
ssl.__dict__['SSLSocket'] = old_sslsocket
if not PY3:
ssl.sslwrap_simple = old_sslwrap_simple
ssl.__dict__['sslwrap_simple'] = old_sslwrap_simple
if pyopenssl_override:
# Replace PyOpenSSL Monkeypatching
inject_into_urllib3()
def create_connection(address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
def _check_worker():
global _checking_lock, _checking_num, network_stat, last_check_time
time_now = time.time()
if config.PROXY_ENABLE:
socket.socket = socks.socksocket
xlog.debug("patch socks")
_checking_lock.acquire()
_checking_num += 1
_checking_lock.release()
try:
conn = httplib.HTTPSConnection("github.com", 443, timeout=30)
header = {"user-agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36",
"accept":"application/json, text/javascript, */*; q=0.01",
"accept-encoding":"gzip, deflate, sdch",
"accept-language":'en-US,en;q=0.8,ja;q=0.6,zh-CN;q=0.4,zh;q=0.2',
"connection":"keep-alive"
}
conn.request("HEAD", "/", headers=header)
response = conn.getresponse()
if response.status:
last_check_time = time.time()
report_network_ok()
xlog.debug("network is ok, cost:%d ms", 1000*(time.time() - time_now))
return True
except Exception as e:
xlog.warn("network fail:%r", e)
network_stat = "Fail"
last_check_time = time.time()
return False
finally:
_checking_lock.acquire()
_checking_num -= 1
_checking_lock.release()
if config.PROXY_ENABLE:
socket.socket = default_socket
xlog.debug("restore socket")
def _simple_check_worker():
global _checking_lock, _checking_num, network_stat, last_check_time
time_now = time.time()
if config.PROXY_ENABLE:
socket.socket = socks.socksocket
xlog.debug("patch socks")
_checking_lock.acquire()
_checking_num += 1
_checking_lock.release()
try:
conn = httplib.HTTPSConnection("www.microsoft.com", 443, timeout=30)
header = {"user-agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36",
"accept":"application/json, text/javascript, */*; q=0.01",
"accept-encoding":"gzip, deflate, sdch",
"accept-language":'en-US,en;q=0.8,ja;q=0.6,zh-CN;q=0.4,zh;q=0.2',
"connection":"keep-alive"
}
conn.request("HEAD", "/", headers=header)
response = conn.getresponse()
if response.status:
last_check_time = time.time()
report_network_ok()
xlog.debug("network is ok, cost:%d ms", 1000*(time.time() - time_now))
return True
except Exception as e:
xlog.warn("network fail:%r", e)
network_stat = "Fail"
last_check_time = time.time()
return False
finally:
_checking_lock.acquire()
_checking_num -= 1
_checking_lock.release()
if config.PROXY_ENABLE:
socket.socket = default_socket
xlog.debug("restore socket")
def download(url, tor=False):
def create_connection(address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
if tor:
if not HAVE_SOCKS:
print_error("Missing dependency, install socks (`pip install SocksiPy`)")
return None
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', 9050)
socket.socket = socks.socksocket
socket.create_connection = create_connection
try:
req = Request(url)
req.add_header('User-agent', 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)')
res = urlopen(req)
data = res.read()
except HTTPError as e:
print_error(e)
except URLError as e:
if tor and e.reason.errno == 111:
print_error("Connection refused, maybe Tor is not running?")
else:
print_error(e)
except Exception as e:
print_error("Failed download: {0}".format(e))
else:
return data
def build_sockets(self):
self.debug.put('Socket Builder started.')
count = 0
while (self.options['attacklimit'] == 0 or self.options['attacklimit'] > self.attacks) and self.running:
if self.options['connectionlimit'] > self.sockets:
if self.options['socksversion'] == 'SOCKS4' or self.options['socksversion'] == 'SOCKS5' or self.options['socksversion'] == 'HTTP':
if self.options['socksversion'] == 'SOCKS4': proxytype = socks.PROXY_TYPE_SOCKS4
elif self.options['socksversion'] == 'SOCKS5': proxytype = socks.PROXY_TYPE_SOCKS5
else: proxytype = socks.PROXY_TYPE_HTTP
s = socks.socksocket()
if self.options['socksuser'] == '' and self.options['sockspass'] == '':
s.setproxy(proxytype, self.options['sockshost'], self.options['socksport'], self.options['socksuser'], self.options['sockspass'])
else:
s.setproxy(proxytype, self.options['sockshost'], self.options['socksport'])
else:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((self.options['host'], self.options['port']))
if self.options['ssl'] == True:
wrap_socket(s)
self.connections.put((s, 0))
self.debug.put('Socket opened, connection created.')
self.attacks += 1
self.sockets += 1
except Exception, ex:
self.errors.put('Could not connect. %s.' % (ex))
if self.options['timebetweenconnections'] > 0:
time.sleep(self.options['timebetweenconnections'])
self.debug.put('Socket Builder finished.')
def __init__(self):
# ?? google.co.jp ?????????
self.url = 'http://www.google.com'
self.url0 = 'http://ip.cn'
self.keyword = 'Anka9080'
self.spider()
# ?? sock5 ??
socks.set_default_proxy(socks.SOCKS5,"127.0.0.1",1080)
socket.socket = socks.socksocket
print len(requests.get(url = self.url, headers = HEADERS).text)
# ?????? urls
def create_connection(address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
def _simple_check_worker():
global _checking_lock, _checking_num, network_stat, last_check_time
time_now = time.time()
if config.PROXY_ENABLE:
socket.socket = socks.socksocket
xlog.debug("patch socks")
_checking_lock.acquire()
_checking_num += 1
_checking_lock.release()
network_ok = False
for host in ["www.microsoft.com", "www.apple.com", "code.jquery.com", "cdn.bootcss.com", "cdnjs.cloudflare.com"]:
if _check_one_host(host):
network_ok = True
break
if network_ok:
last_check_time = time.time()
report_network_ok()
xlog.debug("network is ok, cost:%d ms", 1000 * (time.time() - time_now))
else:
xlog.warn("network fail")
network_stat = "Fail"
last_check_time = time.time()
_checking_lock.acquire()
_checking_num -= 1
_checking_lock.release()
if config.PROXY_ENABLE:
socket.socket = default_socket
xlog.debug("restore socket")
def setProxy(self, host, port):
int_port = int(port)
socks.setdefaultproxy(socks.PROXY_TYPE_HTTP, host, int_port)
socket.socket = socks.socksocket
self.port = port
print 'ipify: ', self.session_get('https://api.ipify.org').content
# -------------------------------------------------------------------------
# setTor proxy
# -------------------------------------------------------------------------
def setTor(self, port):
self.tor = True
int_port = int(port)
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', int_port)
socket.socket = socks.socksocket
self.port = port
self.restartTor()
# -------------------------------------------------------------------------
# restartTor
# -------------------------------------------------------------------------
