|
|
|
|
@ -42,350 +42,350 @@ _defaultproxy = None
@@ -42,350 +42,350 @@ _defaultproxy = None
|
|
|
|
|
_orgsocket = socket.socket |
|
|
|
|
|
|
|
|
|
class ProxyError(Exception): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
class GeneralProxyError(ProxyError): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
class Socks5AuthError(ProxyError): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
class Socks5Error(ProxyError): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
class Socks4Error(ProxyError): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
class HTTPError(ProxyError): |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
def __init__(self, value): |
|
|
|
|
self.value = value |
|
|
|
|
def __str__(self): |
|
|
|
|
return repr(self.value) |
|
|
|
|
|
|
|
|
|
_generalerrors = ("success", |
|
|
|
|
"invalid data", |
|
|
|
|
"not connected", |
|
|
|
|
"not available", |
|
|
|
|
"bad proxy type", |
|
|
|
|
"bad input") |
|
|
|
|
"invalid data", |
|
|
|
|
"not connected", |
|
|
|
|
"not available", |
|
|
|
|
"bad proxy type", |
|
|
|
|
"bad input") |
|
|
|
|
|
|
|
|
|
_socks5errors = ("succeeded", |
|
|
|
|
"general SOCKS server failure", |
|
|
|
|
"connection not allowed by ruleset", |
|
|
|
|
"Network unreachable", |
|
|
|
|
"Host unreachable", |
|
|
|
|
"Connection refused", |
|
|
|
|
"TTL expired", |
|
|
|
|
"Command not supported", |
|
|
|
|
"Address type not supported", |
|
|
|
|
"Unknown error") |
|
|
|
|
"general SOCKS server failure", |
|
|
|
|
"connection not allowed by ruleset", |
|
|
|
|
"Network unreachable", |
|
|
|
|
"Host unreachable", |
|
|
|
|
"Connection refused", |
|
|
|
|
"TTL expired", |
|
|
|
|
"Command not supported", |
|
|
|
|
"Address type not supported", |
|
|
|
|
"Unknown error") |
|
|
|
|
|
|
|
|
|
_socks5autherrors = ("succeeded", |
|
|
|
|
"authentication is required", |
|
|
|
|
"all offered authentication methods were rejected", |
|
|
|
|
"unknown username or invalid password", |
|
|
|
|
"unknown error") |
|
|
|
|
"authentication is required", |
|
|
|
|
"all offered authentication methods were rejected", |
|
|
|
|
"unknown username or invalid password", |
|
|
|
|
"unknown error") |
|
|
|
|
|
|
|
|
|
_socks4errors = ("request granted", |
|
|
|
|
"request rejected or failed", |
|
|
|
|
"request rejected because SOCKS server cannot connect to identd on the client", |
|
|
|
|
"request rejected because the client program and identd report different user-ids", |
|
|
|
|
"unknown error") |
|
|
|
|
"request rejected or failed", |
|
|
|
|
"request rejected because SOCKS server cannot connect to identd on the client", |
|
|
|
|
"request rejected because the client program and identd report different user-ids", |
|
|
|
|
"unknown error") |
|
|
|
|
|
|
|
|
|
def setdefaultproxy(proxytype=None,addr=None,port=None,rdns=True,username=None,password=None): |
|
|
|
|
"""setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) |
|
|
|
|
Sets a default proxy which all further socksocket objects will use, |
|
|
|
|
unless explicitly changed. |
|
|
|
|
""" |
|
|
|
|
global _defaultproxy |
|
|
|
|
_defaultproxy = (proxytype,addr,port,rdns,username,password) |
|
|
|
|
"""setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) |
|
|
|
|
Sets a default proxy which all further socksocket objects will use, |
|
|
|
|
unless explicitly changed. |
|
|
|
|
""" |
|
|
|
|
global _defaultproxy |
|
|
|
|
_defaultproxy = (proxytype,addr,port,rdns,username,password) |
|
|
|
|
|
|
|
|
|
class socksocket(socket.socket): |
|
|
|
|
"""socksocket([family[, type[, proto]]]) -> socket object |
|
|
|
|
|
|
|
|
|
Open a SOCKS enabled socket. The parameters are the same as |
|
|
|
|
those of the standard socket init. In order for SOCKS to work, |
|
|
|
|
you must specify family=AF_INET, type=SOCK_STREAM and proto=0. |
|
|
|
|
""" |
|
|
|
|
|
|
|
|
|
def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None): |
|
|
|
|
_orgsocket.__init__(self,family,type,proto,_sock) |
|
|
|
|
if _defaultproxy != None: |
|
|
|
|
self.__proxy = _defaultproxy |
|
|
|
|
else: |
|
|
|
|
self.__proxy = (None, None, None, None, None, None) |
|
|
|
|
self.__proxysockname = None |
|
|
|
|
self.__proxypeername = None |
|
|
|
|
|
|
|
|
|
def __recvall(self, bytes): |
|
|
|
|
"""__recvall(bytes) -> data |
|
|
|
|
Receive EXACTLY the number of bytes requested from the socket. |
|
|
|
|
Blocks until the required number of bytes have been received. |
|
|
|
|
""" |
|
|
|
|
data = "" |
|
|
|
|
while len(data) < bytes: |
|
|
|
|
d = self.recv(bytes-len(data)) |
|
|
|
|
if not d: |
|
|
|
|
raise GeneralProxyError("connection closed unexpectedly") |
|
|
|
|
data = data + d |
|
|
|
|
return data |
|
|
|
|
|
|
|
|
|
def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None): |
|
|
|
|
"""setproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) |
|
|
|
|
Sets the proxy to be used. |
|
|
|
|
proxytype - The type of the proxy to be used. Three types |
|
|
|
|
are supported: PROXY_TYPE_SOCKS4 (including socks4a), |
|
|
|
|
PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP |
|
|
|
|
addr - The address of the server (IP or DNS). |
|
|
|
|
port - The port of the server. Defaults to 1080 for SOCKS |
|
|
|
|
servers and 8080 for HTTP proxy servers. |
|
|
|
|
rdns - Should DNS queries be preformed on the remote side |
|
|
|
|
(rather than the local side). The default is True. |
|
|
|
|
Note: This has no effect with SOCKS4 servers. |
|
|
|
|
username - Username to authenticate with to the server. |
|
|
|
|
The default is no authentication. |
|
|
|
|
password - Password to authenticate with to the server. |
|
|
|
|
Only relevant when username is also provided. |
|
|
|
|
""" |
|
|
|
|
self.__proxy = (proxytype,addr,port,rdns,username,password) |
|
|
|
|
|
|
|
|
|
def __negotiatesocks5(self,destaddr,destport): |
|
|
|
|
"""__negotiatesocks5(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through a SOCKS5 server. |
|
|
|
|
""" |
|
|
|
|
# First we'll send the authentication packages we support. |
|
|
|
|
if (self.__proxy[4]!=None) and (self.__proxy[5]!=None): |
|
|
|
|
# The username/password details were supplied to the |
|
|
|
|
# setproxy method so we support the USERNAME/PASSWORD |
|
|
|
|
# authentication (in addition to the standard none). |
|
|
|
|
self.sendall("\x05\x02\x00\x02") |
|
|
|
|
else: |
|
|
|
|
# No username/password were entered, therefore we |
|
|
|
|
# only support connections with no authentication. |
|
|
|
|
self.sendall("\x05\x01\x00") |
|
|
|
|
# We'll receive the server's response to determine which |
|
|
|
|
# method was selected |
|
|
|
|
chosenauth = self.__recvall(2) |
|
|
|
|
if chosenauth[0] != "\x05": |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
# Check the chosen authentication method |
|
|
|
|
if chosenauth[1] == "\x00": |
|
|
|
|
# No authentication is required |
|
|
|
|
pass |
|
|
|
|
elif chosenauth[1] == "\x02": |
|
|
|
|
# Okay, we need to perform a basic username/password |
|
|
|
|
# authentication. |
|
|
|
|
self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.__proxy[5])) + self.__proxy[5]) |
|
|
|
|
authstat = self.__recvall(2) |
|
|
|
|
if authstat[0] != "\x01": |
|
|
|
|
# Bad response |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if authstat[1] != "\x00": |
|
|
|
|
# Authentication failed |
|
|
|
|
self.close() |
|
|
|
|
raise Socks5AuthError,((3,_socks5autherrors[3])) |
|
|
|
|
# Authentication succeeded |
|
|
|
|
else: |
|
|
|
|
# Reaching here is always bad |
|
|
|
|
self.close() |
|
|
|
|
if chosenauth[1] == "\xFF": |
|
|
|
|
raise Socks5AuthError((2,_socks5autherrors[2])) |
|
|
|
|
else: |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
# Now we can request the actual connection |
|
|
|
|
req = "\x05\x01\x00" |
|
|
|
|
# If the given destination address is an IP address, we'll |
|
|
|
|
# use the IPv4 address request even if remote resolving was specified. |
|
|
|
|
try: |
|
|
|
|
ipaddr = socket.inet_aton(destaddr) |
|
|
|
|
req = req + "\x01" + ipaddr |
|
|
|
|
except socket.error: |
|
|
|
|
# Well it's not an IP number, so it's probably a DNS name. |
|
|
|
|
if self.__proxy[3]==True: |
|
|
|
|
# Resolve remotely |
|
|
|
|
ipaddr = None |
|
|
|
|
req = req + "\x03" + chr(len(destaddr)) + destaddr |
|
|
|
|
else: |
|
|
|
|
# Resolve locally |
|
|
|
|
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) |
|
|
|
|
req = req + "\x01" + ipaddr |
|
|
|
|
req = req + struct.pack(">H",destport) |
|
|
|
|
self.sendall(req) |
|
|
|
|
# Get the response |
|
|
|
|
resp = self.__recvall(4) |
|
|
|
|
if resp[0] != "\x05": |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
elif resp[1] != "\x00": |
|
|
|
|
# Connection failed |
|
|
|
|
self.close() |
|
|
|
|
if ord(resp[1])<=8: |
|
|
|
|
raise Socks5Error((ord(resp[1]),_generalerrors[ord(resp[1])])) |
|
|
|
|
else: |
|
|
|
|
raise Socks5Error((9,_generalerrors[9])) |
|
|
|
|
# Get the bound address/port |
|
|
|
|
elif resp[3] == "\x01": |
|
|
|
|
boundaddr = self.__recvall(4) |
|
|
|
|
elif resp[3] == "\x03": |
|
|
|
|
resp = resp + self.recv(1) |
|
|
|
|
boundaddr = self.__recvall(ord(resp[4])) |
|
|
|
|
else: |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
boundport = struct.unpack(">H",self.__recvall(2))[0] |
|
|
|
|
self.__proxysockname = (boundaddr,boundport) |
|
|
|
|
if ipaddr != None: |
|
|
|
|
self.__proxypeername = (socket.inet_ntoa(ipaddr),destport) |
|
|
|
|
else: |
|
|
|
|
self.__proxypeername = (destaddr,destport) |
|
|
|
|
|
|
|
|
|
def getproxysockname(self): |
|
|
|
|
"""getsockname() -> address info |
|
|
|
|
Returns the bound IP address and port number at the proxy. |
|
|
|
|
""" |
|
|
|
|
return self.__proxysockname |
|
|
|
|
|
|
|
|
|
def getproxypeername(self): |
|
|
|
|
"""getproxypeername() -> address info |
|
|
|
|
Returns the IP and port number of the proxy. |
|
|
|
|
""" |
|
|
|
|
return _orgsocket.getpeername(self) |
|
|
|
|
|
|
|
|
|
def getpeername(self): |
|
|
|
|
"""getpeername() -> address info |
|
|
|
|
Returns the IP address and port number of the destination |
|
|
|
|
machine (note: getproxypeername returns the proxy) |
|
|
|
|
""" |
|
|
|
|
return self.__proxypeername |
|
|
|
|
|
|
|
|
|
def __negotiatesocks4(self,destaddr,destport): |
|
|
|
|
"""__negotiatesocks4(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through a SOCKS4 server. |
|
|
|
|
""" |
|
|
|
|
# Check if the destination address provided is an IP address |
|
|
|
|
rmtrslv = False |
|
|
|
|
try: |
|
|
|
|
ipaddr = socket.inet_aton(destaddr) |
|
|
|
|
except socket.error: |
|
|
|
|
# It's a DNS name. Check where it should be resolved. |
|
|
|
|
if self.__proxy[3]==True: |
|
|
|
|
ipaddr = "\x00\x00\x00\x01" |
|
|
|
|
rmtrslv = True |
|
|
|
|
else: |
|
|
|
|
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) |
|
|
|
|
# Construct the request packet |
|
|
|
|
req = "\x04\x01" + struct.pack(">H",destport) + ipaddr |
|
|
|
|
# The username parameter is considered userid for SOCKS4 |
|
|
|
|
if self.__proxy[4] != None: |
|
|
|
|
req = req + self.__proxy[4] |
|
|
|
|
req = req + "\x00" |
|
|
|
|
# DNS name if remote resolving is required |
|
|
|
|
# NOTE: This is actually an extension to the SOCKS4 protocol |
|
|
|
|
# called SOCKS4A and may not be supported in all cases. |
|
|
|
|
if rmtrslv==True: |
|
|
|
|
req = req + destaddr + "\x00" |
|
|
|
|
self.sendall(req) |
|
|
|
|
# Get the response from the server |
|
|
|
|
resp = self.__recvall(8) |
|
|
|
|
if resp[0] != "\x00": |
|
|
|
|
# Bad data |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if resp[1] != "\x5A": |
|
|
|
|
# Server returned an error |
|
|
|
|
self.close() |
|
|
|
|
if ord(resp[1]) in (91,92,93): |
|
|
|
|
self.close() |
|
|
|
|
raise Socks4Error((ord(resp[1]),_socks4errors[ord(resp[1])-90])) |
|
|
|
|
else: |
|
|
|
|
raise Socks4Error((94,_socks4errors[4])) |
|
|
|
|
# Get the bound address/port |
|
|
|
|
self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",resp[2:4])[0]) |
|
|
|
|
if rmtrslv != None: |
|
|
|
|
self.__proxypeername = (socket.inet_ntoa(ipaddr),destport) |
|
|
|
|
else: |
|
|
|
|
self.__proxypeername = (destaddr,destport) |
|
|
|
|
|
|
|
|
|
def __negotiatehttp(self,destaddr,destport): |
|
|
|
|
"""__negotiatehttp(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through an HTTP server. |
|
|
|
|
""" |
|
|
|
|
# If we need to resolve locally, we do this now |
|
|
|
|
if self.__proxy[3] == False: |
|
|
|
|
addr = socket.gethostbyname(destaddr) |
|
|
|
|
else: |
|
|
|
|
addr = destaddr |
|
|
|
|
self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n") |
|
|
|
|
# We read the response until we get the string "\r\n\r\n" |
|
|
|
|
resp = self.recv(1) |
|
|
|
|
while resp.find("\r\n\r\n")==-1: |
|
|
|
|
resp = resp + self.recv(1) |
|
|
|
|
# We just need the first line to check if the connection |
|
|
|
|
# was successful |
|
|
|
|
statusline = resp.splitlines()[0].split(" ",2) |
|
|
|
|
if statusline[0] not in ("HTTP/1.0","HTTP/1.1"): |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
try: |
|
|
|
|
statuscode = int(statusline[1]) |
|
|
|
|
except ValueError: |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if statuscode != 200: |
|
|
|
|
self.close() |
|
|
|
|
raise HTTPError((statuscode,statusline[2])) |
|
|
|
|
self.__proxysockname = ("0.0.0.0",0) |
|
|
|
|
self.__proxypeername = (addr,destport) |
|
|
|
|
|
|
|
|
|
def connect(self,destpair): |
|
|
|
|
"""connect(self,despair) |
|
|
|
|
Connects to the specified destination through a proxy. |
|
|
|
|
destpar - A tuple of the IP/DNS address and the port number. |
|
|
|
|
(identical to socket's connect). |
|
|
|
|
To select the proxy server use setproxy(). |
|
|
|
|
""" |
|
|
|
|
# Do a minimal input check first |
|
|
|
|
if (type(destpair) in (list,tuple)==False) or (len(destpair)<2) or (type(destpair[0])!=str) or (type(destpair[1])!=int): |
|
|
|
|
raise GeneralProxyError((5,_generalerrors[5])) |
|
|
|
|
if self.__proxy[0] == PROXY_TYPE_SOCKS5: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 1080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatesocks5(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == PROXY_TYPE_SOCKS4: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 1080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatesocks4(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == PROXY_TYPE_HTTP: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 8080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatehttp(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == None: |
|
|
|
|
_orgsocket.connect(self,(destpair[0],destpair[1])) |
|
|
|
|
else: |
|
|
|
|
raise GeneralProxyError((4,_generalerrors[4])) |
|
|
|
|
"""socksocket([family[, type[, proto]]]) -> socket object |
|
|
|
|
|
|
|
|
|
Open a SOCKS enabled socket. The parameters are the same as |
|
|
|
|
those of the standard socket init. In order for SOCKS to work, |
|
|
|
|
you must specify family=AF_INET, type=SOCK_STREAM and proto=0. |
|
|
|
|
""" |
|
|
|
|
|
|
|
|
|
def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None): |
|
|
|
|
_orgsocket.__init__(self,family,type,proto,_sock) |
|
|
|
|
if _defaultproxy != None: |
|
|
|
|
self.__proxy = _defaultproxy |
|
|
|
|
else: |
|
|
|
|
self.__proxy = (None, None, None, None, None, None) |
|
|
|
|
self.__proxysockname = None |
|
|
|
|
self.__proxypeername = None |
|
|
|
|
|
|
|
|
|
def __recvall(self, bytes): |
|
|
|
|
"""__recvall(bytes) -> data |
|
|
|
|
Receive EXACTLY the number of bytes requested from the socket. |
|
|
|
|
Blocks until the required number of bytes have been received. |
|
|
|
|
""" |
|
|
|
|
data = "" |
|
|
|
|
while len(data) < bytes: |
|
|
|
|
d = self.recv(bytes-len(data)) |
|
|
|
|
if not d: |
|
|
|
|
raise GeneralProxyError("connection closed unexpectedly") |
|
|
|
|
data = data + d |
|
|
|
|
return data |
|
|
|
|
|
|
|
|
|
def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None): |
|
|
|
|
"""setproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) |
|
|
|
|
Sets the proxy to be used. |
|
|
|
|
proxytype - The type of the proxy to be used. Three types |
|
|
|
|
are supported: PROXY_TYPE_SOCKS4 (including socks4a), |
|
|
|
|
PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP |
|
|
|
|
addr - The address of the server (IP or DNS). |
|
|
|
|
port - The port of the server. Defaults to 1080 for SOCKS |
|
|
|
|
servers and 8080 for HTTP proxy servers. |
|
|
|
|
rdns - Should DNS queries be preformed on the remote side |
|
|
|
|
(rather than the local side). The default is True. |
|
|
|
|
Note: This has no effect with SOCKS4 servers. |
|
|
|
|
username - Username to authenticate with to the server. |
|
|
|
|
The default is no authentication. |
|
|
|
|
password - Password to authenticate with to the server. |
|
|
|
|
Only relevant when username is also provided. |
|
|
|
|
""" |
|
|
|
|
self.__proxy = (proxytype,addr,port,rdns,username,password) |
|
|
|
|
|
|
|
|
|
def __negotiatesocks5(self,destaddr,destport): |
|
|
|
|
"""__negotiatesocks5(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through a SOCKS5 server. |
|
|
|
|
""" |
|
|
|
|
# First we'll send the authentication packages we support. |
|
|
|
|
if (self.__proxy[4]!=None) and (self.__proxy[5]!=None): |
|
|
|
|
# The username/password details were supplied to the |
|
|
|
|
# setproxy method so we support the USERNAME/PASSWORD |
|
|
|
|
# authentication (in addition to the standard none). |
|
|
|
|
self.sendall("\x05\x02\x00\x02") |
|
|
|
|
else: |
|
|
|
|
# No username/password were entered, therefore we |
|
|
|
|
# only support connections with no authentication. |
|
|
|
|
self.sendall("\x05\x01\x00") |
|
|
|
|
# We'll receive the server's response to determine which |
|
|
|
|
# method was selected |
|
|
|
|
chosenauth = self.__recvall(2) |
|
|
|
|
if chosenauth[0] != "\x05": |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
# Check the chosen authentication method |
|
|
|
|
if chosenauth[1] == "\x00": |
|
|
|
|
# No authentication is required |
|
|
|
|
pass |
|
|
|
|
elif chosenauth[1] == "\x02": |
|
|
|
|
# Okay, we need to perform a basic username/password |
|
|
|
|
# authentication. |
|
|
|
|
self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.__proxy[5])) + self.__proxy[5]) |
|
|
|
|
authstat = self.__recvall(2) |
|
|
|
|
if authstat[0] != "\x01": |
|
|
|
|
# Bad response |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if authstat[1] != "\x00": |
|
|
|
|
# Authentication failed |
|
|
|
|
self.close() |
|
|
|
|
raise Socks5AuthError,((3,_socks5autherrors[3])) |
|
|
|
|
# Authentication succeeded |
|
|
|
|
else: |
|
|
|
|
# Reaching here is always bad |
|
|
|
|
self.close() |
|
|
|
|
if chosenauth[1] == "\xFF": |
|
|
|
|
raise Socks5AuthError((2,_socks5autherrors[2])) |
|
|
|
|
else: |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
# Now we can request the actual connection |
|
|
|
|
req = "\x05\x01\x00" |
|
|
|
|
# If the given destination address is an IP address, we'll |
|
|
|
|
# use the IPv4 address request even if remote resolving was specified. |
|
|
|
|
try: |
|
|
|
|
ipaddr = socket.inet_aton(destaddr) |
|
|
|
|
req = req + "\x01" + ipaddr |
|
|
|
|
except socket.error: |
|
|
|
|
# Well it's not an IP number, so it's probably a DNS name. |
|
|
|
|
if self.__proxy[3]==True: |
|
|
|
|
# Resolve remotely |
|
|
|
|
ipaddr = None |
|
|
|
|
req = req + "\x03" + chr(len(destaddr)) + destaddr |
|
|
|
|
else: |
|
|
|
|
# Resolve locally |
|
|
|
|
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) |
|
|
|
|
req = req + "\x01" + ipaddr |
|
|
|
|
req = req + struct.pack(">H",destport) |
|
|
|
|
self.sendall(req) |
|
|
|
|
# Get the response |
|
|
|
|
resp = self.__recvall(4) |
|
|
|
|
if resp[0] != "\x05": |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
elif resp[1] != "\x00": |
|
|
|
|
# Connection failed |
|
|
|
|
self.close() |
|
|
|
|
if ord(resp[1])<=8: |
|
|
|
|
raise Socks5Error((ord(resp[1]),_generalerrors[ord(resp[1])])) |
|
|
|
|
else: |
|
|
|
|
raise Socks5Error((9,_generalerrors[9])) |
|
|
|
|
# Get the bound address/port |
|
|
|
|
elif resp[3] == "\x01": |
|
|
|
|
boundaddr = self.__recvall(4) |
|
|
|
|
elif resp[3] == "\x03": |
|
|
|
|
resp = resp + self.recv(1) |
|
|
|
|
boundaddr = self.__recvall(ord(resp[4])) |
|
|
|
|
else: |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
boundport = struct.unpack(">H",self.__recvall(2))[0] |
|
|
|
|
self.__proxysockname = (boundaddr,boundport) |
|
|
|
|
if ipaddr != None: |
|
|
|
|
self.__proxypeername = (socket.inet_ntoa(ipaddr),destport) |
|
|
|
|
else: |
|
|
|
|
self.__proxypeername = (destaddr,destport) |
|
|
|
|
|
|
|
|
|
def getproxysockname(self): |
|
|
|
|
"""getsockname() -> address info |
|
|
|
|
Returns the bound IP address and port number at the proxy. |
|
|
|
|
""" |
|
|
|
|
return self.__proxysockname |
|
|
|
|
|
|
|
|
|
def getproxypeername(self): |
|
|
|
|
"""getproxypeername() -> address info |
|
|
|
|
Returns the IP and port number of the proxy. |
|
|
|
|
""" |
|
|
|
|
return _orgsocket.getpeername(self) |
|
|
|
|
|
|
|
|
|
def getpeername(self): |
|
|
|
|
"""getpeername() -> address info |
|
|
|
|
Returns the IP address and port number of the destination |
|
|
|
|
machine (note: getproxypeername returns the proxy) |
|
|
|
|
""" |
|
|
|
|
return self.__proxypeername |
|
|
|
|
|
|
|
|
|
def __negotiatesocks4(self,destaddr,destport): |
|
|
|
|
"""__negotiatesocks4(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through a SOCKS4 server. |
|
|
|
|
""" |
|
|
|
|
# Check if the destination address provided is an IP address |
|
|
|
|
rmtrslv = False |
|
|
|
|
try: |
|
|
|
|
ipaddr = socket.inet_aton(destaddr) |
|
|
|
|
except socket.error: |
|
|
|
|
# It's a DNS name. Check where it should be resolved. |
|
|
|
|
if self.__proxy[3]==True: |
|
|
|
|
ipaddr = "\x00\x00\x00\x01" |
|
|
|
|
rmtrslv = True |
|
|
|
|
else: |
|
|
|
|
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) |
|
|
|
|
# Construct the request packet |
|
|
|
|
req = "\x04\x01" + struct.pack(">H",destport) + ipaddr |
|
|
|
|
# The username parameter is considered userid for SOCKS4 |
|
|
|
|
if self.__proxy[4] != None: |
|
|
|
|
req = req + self.__proxy[4] |
|
|
|
|
req = req + "\x00" |
|
|
|
|
# DNS name if remote resolving is required |
|
|
|
|
# NOTE: This is actually an extension to the SOCKS4 protocol |
|
|
|
|
# called SOCKS4A and may not be supported in all cases. |
|
|
|
|
if rmtrslv==True: |
|
|
|
|
req = req + destaddr + "\x00" |
|
|
|
|
self.sendall(req) |
|
|
|
|
# Get the response from the server |
|
|
|
|
resp = self.__recvall(8) |
|
|
|
|
if resp[0] != "\x00": |
|
|
|
|
# Bad data |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if resp[1] != "\x5A": |
|
|
|
|
# Server returned an error |
|
|
|
|
self.close() |
|
|
|
|
if ord(resp[1]) in (91,92,93): |
|
|
|
|
self.close() |
|
|
|
|
raise Socks4Error((ord(resp[1]),_socks4errors[ord(resp[1])-90])) |
|
|
|
|
else: |
|
|
|
|
raise Socks4Error((94,_socks4errors[4])) |
|
|
|
|
# Get the bound address/port |
|
|
|
|
self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",resp[2:4])[0]) |
|
|
|
|
if rmtrslv != None: |
|
|
|
|
self.__proxypeername = (socket.inet_ntoa(ipaddr),destport) |
|
|
|
|
else: |
|
|
|
|
self.__proxypeername = (destaddr,destport) |
|
|
|
|
|
|
|
|
|
def __negotiatehttp(self,destaddr,destport): |
|
|
|
|
"""__negotiatehttp(self,destaddr,destport) |
|
|
|
|
Negotiates a connection through an HTTP server. |
|
|
|
|
""" |
|
|
|
|
# If we need to resolve locally, we do this now |
|
|
|
|
if self.__proxy[3] == False: |
|
|
|
|
addr = socket.gethostbyname(destaddr) |
|
|
|
|
else: |
|
|
|
|
addr = destaddr |
|
|
|
|
self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n") |
|
|
|
|
# We read the response until we get the string "\r\n\r\n" |
|
|
|
|
resp = self.recv(1) |
|
|
|
|
while resp.find("\r\n\r\n")==-1: |
|
|
|
|
resp = resp + self.recv(1) |
|
|
|
|
# We just need the first line to check if the connection |
|
|
|
|
# was successful |
|
|
|
|
statusline = resp.splitlines()[0].split(" ",2) |
|
|
|
|
if statusline[0] not in ("HTTP/1.0","HTTP/1.1"): |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
try: |
|
|
|
|
statuscode = int(statusline[1]) |
|
|
|
|
except ValueError: |
|
|
|
|
self.close() |
|
|
|
|
raise GeneralProxyError((1,_generalerrors[1])) |
|
|
|
|
if statuscode != 200: |
|
|
|
|
self.close() |
|
|
|
|
raise HTTPError((statuscode,statusline[2])) |
|
|
|
|
self.__proxysockname = ("0.0.0.0",0) |
|
|
|
|
self.__proxypeername = (addr,destport) |
|
|
|
|
|
|
|
|
|
def connect(self,destpair): |
|
|
|
|
"""connect(self,despair) |
|
|
|
|
Connects to the specified destination through a proxy. |
|
|
|
|
destpar - A tuple of the IP/DNS address and the port number. |
|
|
|
|
(identical to socket's connect). |
|
|
|
|
To select the proxy server use setproxy(). |
|
|
|
|
""" |
|
|
|
|
# Do a minimal input check first |
|
|
|
|
if (type(destpair) in (list,tuple)==False) or (len(destpair)<2) or (type(destpair[0])!=str) or (type(destpair[1])!=int): |
|
|
|
|
raise GeneralProxyError((5,_generalerrors[5])) |
|
|
|
|
if self.__proxy[0] == PROXY_TYPE_SOCKS5: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 1080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatesocks5(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == PROXY_TYPE_SOCKS4: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 1080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatesocks4(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == PROXY_TYPE_HTTP: |
|
|
|
|
if self.__proxy[2] != None: |
|
|
|
|
portnum = self.__proxy[2] |
|
|
|
|
else: |
|
|
|
|
portnum = 8080 |
|
|
|
|
_orgsocket.connect(self,(self.__proxy[1],portnum)) |
|
|
|
|
self.__negotiatehttp(destpair[0],destpair[1]) |
|
|
|
|
elif self.__proxy[0] == None: |
|
|
|
|
_orgsocket.connect(self,(destpair[0],destpair[1])) |
|
|
|
|
else: |
|
|
|
|
raise GeneralProxyError((4,_generalerrors[4])) |
|
|
|
|
|
DoumanAsh
10 years ago