WebProxy46
Zur Navigation springen
Zur Suche springen
#!/usr/bin/python
# Copyright (c) 2013 by Peter_Siegrist(SystemLoesungen) (PSS @ ZweierNet.ch)
# www.IPv6Tech.ch
#
# All Rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# This is a simple IPv4-IPv6 non-caching HTTP/HTTPS Proxy/Gateway.
# The Server can make both IPv6, primarily, or IPv4 requestst on behalf of the pure IPv4 clients.
#
# WebProxy46 does not filter any messages apart from chanching HTTP/1.1 to HTTP/1.0
# because we do not want to filter out subrequests in persistent connections.
#
# All standard methodes are supported: GET, HEAD, POST, PUT, OPTIONS, TRACE and DELETE.
# The CONNECT method is used for SSL connections. Only port 443 is allowed with this method (HTTP CONNECT Vulnerability)
#
# For using this proxy configure your browser to use proxy service.
# The servers standard binding is port 9090 on address 0.0.0.0
#
# Accepted schemes are HTTP HTTPS and FTP.
# Hostnames in URL's may be given as FQDN, IPv4 dotted address or IPv6 address in square brackets form [xx:xx:xx::x]
#
import socket
import getopt
import sys
from select import select
import logging
import thread
import struct
import string
#-- Vars
version = 'WebProxy46/v0.7'
buflen = 8192
listen_host = '0.0.0.0'
listen_port = 9090
debug = False
lfnr = 0
#-- Threaded Main Object
class ProxyHandler:
def __init__(self, local_conn, local_address):
global lfnr
lfnr += 1
self.lfnr = lfnr
log(self.lfnr,'NEW Connect ...')
self.local_client = local_conn
self.local_client_address = local_address
self.local_client_buffer = ''
self.timeout = 60
self.handle()
self.local_client.close()
def _set_target_sockopts_ssl(self):
self.target.setsockopt(socket.SOL_SOCKET,socket.MSG_DONTWAIT,1)
self.target.setblocking(1)
def handle(self):
try:
self.local_client.setblocking(1)
self.local_client.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 20))
#self.local_client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 0)
clt_count = 0
while 1:
clt_count += 1
(client_data, _, client_error) = select([self.local_client], [], [], 1)
if client_data:
data = self.local_client.recv(buflen)
if len(data) == 0:
break
self.local_client_buffer += data
log2(self.lfnr,"data:%s"%data)
if client_error:
err = select.error
log(self.lfnr,"%s - Client_Error select: %s on %s " % (self.af, err, self.local_client_address))
if clt_count == 1:
break
if self.local_client_buffer:
end_head = self.local_client_buffer.find('\n')
log(self.lfnr,'%s'%self.local_client_buffer[:end_head])
self.method, self.path, self.protocol = (self.local_client_buffer[:end_head+1]).split()
self.local_client_buffer = self.local_client_buffer[end_head+1:]
# we can't handle 1.1 persistent connections in proxys, thanks mozilla :(
self.protocol = string.replace(self.protocol, 'HTTP/1.1', 'HTTP/1.0')
if self.method=='CONNECT':
self.method_ssl()
elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE'):
self.method_get()
else:
self.method_invalid()
try:
self.target.close()
except:
pass
except Exception as uerr:
log(self.lfnr,'__Unexpected Error__: %s'%uerr)
def method_invalid(self):
log(self.lfnr,'Invalid HTTP Method: %s'%self.method)
self.local_client.send('HTTP/1.1 501 Not Implemented\r\n'+'Unknown method: %s\r\n\r\n'%self.method)
self.local_client_buffer = ''
self.local_client.close()
def method_ssl(self):
if not self.connect_target(self.path):
self.local_client.send('HTTP/1.1 500\r\n\r\n')
self.local_client.send('HTTP/1.1 500 %s\r\nProxy: %s\r\n\r\n'%(self.conn_error,version))
return False
#self.local_client.send('HTTP/1.1 200 OK\r\n\r\n')
self.local_client.send('HTTP/1.1 200 Connection established\r\n'+'Proxy: %s\r\n\r\n'%version)
self.local_client_buffer = ''
self.handle_select()
def method_get(self):
j = self.path.find('://')
self.scheme = self.path[:j]
self.path = self.path[j+3:]
i = self.path.find('/')
host = self.path[:i]
path = self.path[i:]
if not self.connect_target(host):
self.local_client.send('HTTP/1.1 500\r\n\r\n')
self.local_client.send('HTTP/1.1 500 %s\r\nProxy: %s\r\n\r\n'%(self.conn_error,version))
return False
s1 = self.target.send('%s %s %s\r\n'%(self.method, path, self.protocol)+self.local_client_buffer)
log2(self.lfnr,'SEND_RAW(to %s):%s %s %s\n'%(self.target_addr[0:2],self.method, path, self.protocol)+self.local_client_buffer)
log(self.lfnr,'SEND_REQUEST(to %s): %s %s %s\n'%(self.target_addr[0:2], self.method, path, self.protocol))
self.local_client_buffer = ''
self.handle_select()
def connect_target(self, host):
if host.find('[') != -1:
j = host.find(']:')
if j!=-1:
port = int(host[j+2:])
host = host[1:j]
else:
host = host[1:-1]
if self.scheme.lower() == 'ftp':
port = 21
else:
port = 80
else:
i = host.find(':')
if i!=-1:
port = int(host[i+1:])
host = host[:i]
else:
if self.scheme.lower() == 'ftp':
port = 21
else:
port = 80
if self.method=='CONNECT':
if port != 443:
self.conn_error = 'Connection refused. Port %d not allowed in CONNECT method'%port
return False
try:
addrinfo = socket.getaddrinfo(host, port)
except socket.error as msg:
log(self.lfnr,"Error resolving %s:%d: %s" % (host, port, msg))
self.conn_error = 'Error resolving %s:%d: %s'%(host, port,msg[1])
return False
for (afm, _, _, _, address) in addrinfo:
if afm == socket.AF_INET6:
self.target = socket.socket(socket.AF_INET6)
self.target_addr = address
self.af = 'IPv6'
break
elif afm == socket.AF_INET:
self.target = socket.socket(socket.AF_INET)
self.target_addr = address
self.af = 'IPv4'
else:
log(self.lfnr,"EEERRRRRRRRRRRRRRRRRRRR\n")
self.target.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 0)
self.target.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 10))
try:
self.target.connect(self.target_addr)
except socket.error as msg:
log(self.lfnr,"%s - Error connecting %s:%d (Addr: %s): %s" % (self.af, host, port, self.target_addr, msg))
self.conn_error = 'Connection failed: %s'%msg[1]
return False
else:
log(self.lfnr,"%s - connect to %s:%d (%s)" % (self.af, host, port, self.target_addr[0:2]))
return True
def handle_select(self):
self.soc_pair = [self.local_client, self.target]
count = 0
rf = 'undefined'
while 1:
count += 1
(recv_data, _, error) = select(self.soc_pair, [], self.soc_pair, 2)
if recv_data:
cnt = 0
for i in recv_data:
cnt +=1
if i is self.local_client:
rf = self.local_client_address
else:
rf = self.target_addr
try:
data = i.recv(buflen)
except socket.error as err:
log(self.lfnr,'recv error (%s):%s' % (rf, err))
if err[0] == 104: # connection reset by peer
continue
log2(self.lfnr,'%d %d select handle from: %s LEN: %d' % (count,cnt,rf,len(data)))
if len(data) == 0:
continue
if i is self.local_client:
#self.view_sockopts(self.local_client)
if 'HTTP/1.' in data:
bs = data.find('\n')
log(self.lfnr,'%s - Request from %s: %s'%(self.af,self.local_client_address[0:2],data[:bs-1]))
rf = self.local_client_address
log2(self.lfnr,'DATA(to %s from %s):%s'% (self.target_addr,rf,data[:260]))
out = self.target
elif i is self.target:
if 'HTTP/1.' in data[0:8]:
bs = data[0:256].find('\n')
log(self.lfnr,'%s - Answer from %s: %s'%(self.af,self.target_addr[0:2],data[:bs-1]))
rf = self.target_addr
log2(self.lfnr,'DATA(to %s from %s):%s'% (self.local_client_address,rf,data[:260]))
out = self.local_client
else:
log(self.lfnr,"EEEEEERRRRRROOOORRRRRRRRR: %s"% i)
if data:
try:
sent_byte = out.send(data)
except socket.error as err:
log(self.lfnr,'send error (%s):%s' % (rf, err))
else:
log2(self.lfnr,'Sent %d Bytes Data to %s' % (sent_byte,out.getpeername()[0:2]))
count = 0
if error:
err = select.error
log(self.lfnr,"%s - Error select: %s on %s:%s " % (self.af, err, self.local_client_address, self.target_addr))
if count == 10:
break
def view_sockopts(self,s):
socket_options = [ (getattr(socket, opt), opt) for opt in dir(socket) if opt.startswith('SO_') ]
socket_options.sort()
for num, opt in socket_options:
try:
val = s.getsockopt(socket.SOL_SOCKET, num)
log2(self.lfnr,'%s(%d) defaults to %d' % (opt, num, val))
except (socket.error) as e:
log2(self.lfnr,'%s(%d) can\'t help you out there: %s' % (opt, num, str(e)))
# -- Main functions
def log(lfnr,msg):
logging.warn('[%s] %s'%(lfnr,msg))
def log2(lfnr,msg):
if debug:
logging.warn('[%s] %s'%(lfnr,msg))
def usage():
print(sys.argv[0]),
print(" [-p port] [-s host] [-l logfile] [-d] [-h]")
print('')
print(" -p - Port to listen on")
print(" -s - Host to listen on. If not specified, 0.0.0.0 is used")
print(" -l - Path to logfile. If not specified, STDOUT is used")
print(" -d - debug messages")
print('')
def main(host, port):
logfile = None
try:
opts, args = getopt.getopt(sys.argv[1:], "l:hdp:s:", [])
except getopt.GetoptError:
usage()
return 1
for opt, value in opts:
if opt == "-p": port = int(value)
if opt == "-s": host = value
if opt == "-l": logfile = value
if opt == "-d":
global debug
debug = True
if opt == "-h":
usage()
return 0
if not socket.has_ipv6:
print("This machine is not IPv6 capable. Exiting.\n")
exit(1)
logging.basicConfig(format='%(asctime)s %(thread)s: %(message)s',
filename=logfile)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((host, port))
log(lfnr,"Start Server")
log(lfnr,"Listen on %s:%d"%(host, port))
server_socket.listen(10)
while 1:
thread.start_new_thread(ProxyHandler, server_socket.accept())
if __name__ == '__main__':
main(listen_host, listen_port)