def tracker_update(tracker_hostname, tracker_port, request, app_name, hostname,
port, key, pk):
conn = TCPConnection()
conn.connect(tracker_hostname, tracker_port)
data = {
'request': request,
'params': {
'app': app_name,
'hostname': hostname,
'port': port
}
}
bstr = Wrap.reduceToBytes(Wrap.dictToBen(data))
reqd = {
'request-data': {
'data': data,
'type': "POST",
'key': str(b64encode(host.gen_key_str(key)), encoding='utf-8'),
'sign': str(b64encode(host.sign_str(pk, bstr=bstr)),
encoding='utf-8')
},
'request-type': 'new'
}
req = client.request(reqd)
client.request_send(conn, req)
b = client.response_recv(conn)
d = client.response(b)
conn.close()
return d
data_sign = str(b64encode(
host.sign_str(pk, bstr=Wrap.reduceToBytes(Wrap.dictToBen(params)))),
encoding='utf-8')
data = {
'request': ['post'],
'params': params,
'data-sign': data_sign
# 'sign': input(),
# 'ring': str(ring)
}
bstr = Wrap.reduceToBytes(Wrap.dictToBen(data))
reqd = {
'request-data': {
'data': data,
'type': "POST",
'key': str(b64encode(host.gen_key_str(key)), encoding='utf-8'),
'sign': str(b64encode(host.sign_str(pk, bstr=bstr)),
encoding='utf-8')
},
'request-type': 'new'
}
req = client.request(reqd)
# udp = UDPConnection()
# udp.send(req,('127.0.0.1',1024))
# data,addr = udp.recv()
# print(data,addr)
client.request_send(conn, req)
b = client.response_recv(conn)
d = client.response(b)
# if reqd['request-data']['type'] == 'POST':
# b2 = client.response_recv(conn)
from anarchy.database.sqlite.db import db
from anarchy.cryptography.host import host
database = db("SERVER.db")
base = database.base
pk = host.load_pk('TRACKER_PK', b'1234')
key = host.load_key('TRACKER_KEY')
key_str = host.gen_key_str(key)
def xor_replication_post(trac, database):
if trac['response-data']['data']['status'] == 'empty':
return
sesson = database.new_session()
respd = None
rows = sesson.query(Post).order_by(Post.id).all()
r = len(rows)
database.sesson_close(sesson)
while r > 0:
print(r)
xor_key = rows[r - 1].xor
data = {
'request': ['replicate'],
'params': {
'xor': xor_key,
}
}
bstr = Wrap.reduceToBytes(Wrap.dictToBen(data))
reqd = {
'request-data': {
'data':
data,
'type':
"GET",
'key':
str(b64encode(host.gen_key_str(key)), encoding='utf-8'),
'sign':
str(b64encode(host.sign_str(pk, bstr=bstr)), encoding='utf-8')
},
'request-type': 'new'
}
fw_conn = TCPConnection()
try:
fw_conn.connect(trac['response-data']['data']['db'][0],
trac['response-data']['data']['db'][1])
except ConnectionRefusedError:
break
req = client.request(reqd)
client.request_send(fw_conn, req)
resp = client.response_recv(fw_conn)
respd = client.response(resp)
fw_conn.close()
if (respd['response-data']['data']['status'] == 'NOT_FOUND'):
r -= 1
# time.sleep(1)
else:
break
if respd is None:
return
sesson = database.new_session()
print(respd['response-data']['data']['response'])
for i in range(len(respd['response-data']['data']['response'])):
if len(
sesson.query(Post).filter_by(
sign=respd['response-data']['data']['response'][i]
['sign']).all()) > 0:
continue
userlst = sesson.query(User).filter_by(
key=respd['response-data']['data']['response'][i]['key']).all()
if len(userlst) == 0:
u = User(key=respd['response-data']['data']['response'][i]['key'])
sesson.add(u)
user = sesson.query(User).filter_by(
key=respd['response-data']['data']['response'][i]['key'])[0]
xor = int(sesson.query(Post).all()[-1].xor, base=16)
xor ^= int(helper.binToHex(
host.hash(
bytes(respd['response-data']['data']['response'][i]['sign'],
encoding='utf-8'))),
base=16)
post = Post(text=respd['response-data']['data']['response'][i]['text'],
sign=respd['response-data']['data']['response'][i]['sign'],
user=user,
xor=hex(xor)[2:])
sesson.add(post)
sesson.commit()
database.sesson_close(sesson)