def connect_to_onet(UOkey, nickname, sock):
onet = socket(AF_INET, SOCK_STREAM)
onet.bind((config['local_ip'], 0))
onet.connect(("czat-app.onet.pl", 5015))
send(sock, recv(onet, 1024))
send(onet, "AUTHKEY\r\n")
send(onet, "NICK " + nickname + "\r\n")
send(onet, ("USER * " + UOkey + " czat-app.onet.pl :" + nickname + "\r\n"))
authkey = auth(findall(":.*?801.*?:(.*?)\r", recv(onet, 1024))[0])
send(onet, "AUTHKEY " + authkey + "\r\n")
return onet
def mainLoop(client_socket, config):
config['nickname'], config['password'] = receive_nickname_and_password(client_socket)
try:
checkTunnelPassword(config['password'],config['TUNEL_PASS'])
config['password'] = splitPassword(config['password'], config['TUNEL_PASS'])
config['UOkey'] = authorization(config['nickname'], config['password'])
except Exception as e:
print(e)
client_socket.close()
return
onet_socket = connect_to_onet(config['UOkey'], config['nickname'], client_socket)
send_welcome_messages(config, client_socket)
while 1:
(sockets_with_ready_messages, dw, de) = select.select([client_socket, onet_socket], [], [])
for socket_with_ready_msg in sockets_with_ready_messages:
if socket_with_ready_msg == client_socket:
try:
received_message = recv(socket_with_ready_msg, 1024)
if received_message:
config['encode'] = get_proper_encoding(received_message, config['encode'])
received_message = applyEncoding(received_message, config['encode'], config['lemoty'])
config = handleMessageFromClient(received_message, config, onet_socket, client_socket)
else:
client_socket.close()
onet_socket.close()
break
except Exception as e:
print(e)
client_socket.close()
onet_socket.close()
if socket_with_ready_msg == onet_socket:
received_message = ""
try:
while 1:
chunk_of_received_msg = recv(socket_with_ready_msg, 1024)
if chunk_of_received_msg:
if chunk_of_received_msg[len(chunk_of_received_msg) - 1] == '\n':
received_message += chunk_of_received_msg
break
else:
client_socket.close()
onet_socket.close()
break
received_message += chunk_of_received_msg
handleMessageFromOnet(config, client_socket, received_message)
except:
client_socket.close()
onet_socket.close()
def main(argv):
if len(argv) < 3:
print("need 2 arguments")
return 1
# ringmaster socket
host, port = (sys.argv[1], int(sys.argv[2]))
rm_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
rm_sock.connect((host, port))
# listening socket
ln_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ln_sock.bind(('', 0))
ln_sock.listen()
ln_addr = Address.new()
host, port = ln_sock.getsockname()
ln_addr.set_host(host)
ln_addr.set_port(port)
util.send(rm_sock, ln_addr)
info = util.recv(rm_sock, PlayerInfo)
n_player = info.total()
self_id = info.id()
# connecting socket
cn_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cn_sock.connect((info.next().host(), info.next().port()))
# incoming connection
in_conn, in_addr = ln_sock.accept()
while True:
rlist, wlist, xlist = select.select([rm_sock, cn_sock, in_conn], [],
[])
for sock in rlist:
potato = util.recv(sock, Potato)
if potato is None: # shutdown?
return 0
assert potato.ttl() > 0
potato1 = append_trace(potato, self_id)
if potato1.ttl() == 0:
print("I'm it.")
pick_fd = rm_sock
else:
pick_dir = 2 * random.randrange(0, 2) - 1
pick = (self_id + pick_dir + n_player) % n_player
print("Sending potato to player", pick)
pick_fd = cn_sock if pick_dir > 0 else in_conn
util.send(pick_fd, potato1)
if pick_fd == rm_sock:
return 0
def _prove_simple(sock,
gamma,
r,
s,
g=Constants.G,
p=Constants.P,
q=Constants.Q):
assert (len(r) == len(s))
n = len(r)
# step 1
t = recv(sock)
# step 2
r_hat = [(r[i] - t) % q for i in range(n)]
s_hat = [(s[i] - gamma * t) % q for i in range(n)]
theta = [0] + [randkey(0, q - 1) for _ in range(2 * n - 1)]
Theta = []
for i in range(2 * n):
if i < n:
exp = (theta[i] * r_hat[i]) % q
exp -= (theta[i + 1] * s_hat[i]) % q
exp %= q
Theta.append(powm(g, exp, p))
else:
exp = (theta[i] * gamma) % q
exp -= theta[(i + 1) % (2 * n)]
exp %= q
Theta.append(powm(g, exp, p))
send(sock, Theta)
# step 3
c = recv(sock)
# step 4
alpha = [c]
tmp = c
for i in range(2 * n - 1):
if i < n:
tmp = (tmp * divide(r_hat[i], s_hat[i], q)) % q
alpha.append((tmp + theta[i + 1]) % q)
elif i == n:
inv = modinv(gamma, q)
tmp = (c * powm(inv, (2 * n - 1) - i, q)) % q
alpha.append((tmp + theta[i + 1]) % q)
else:
tmp = (tmp * gamma) % q
alpha.append((tmp + theta[i + 1]) % q)
send(sock, alpha)
def main(argv):
if len(argv) < 3:
print("need 2 arguments")
return 1
ln_port = int(argv[1])
n_player = int(argv[2])
n_hop = int(argv[3])
assert n_player > 0
assert n_hop >= 0
ln_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ln_sock.bind(('', ln_port))
ln_sock.listen()
pl_socks = []
pl_addrs = []
for i in range(n_player):
pl_sock, pl_addr = ln_sock.accept()
addr = util.recv(pl_sock, Address)
addr.set_host(pl_addr[0])
pl_socks.append(pl_sock)
pl_addrs.append(addr)
for i in range(n_player):
info = PlayerInfo.new()
info.set_id(i)
info.set_total(n_player)
j = i - 1 if i > 0 else n_player - 1
k = i + 1 if i < n_player - 1 else 0
copy_address(info.init_prev(), pl_addrs[j])
copy_address(info.init_next(), pl_addrs[k])
util.send(pl_socks[i], info)
potato = Potato.new()
potato.set_ttl(n_hop)
if n_hop > 0:
pick = random.randrange(0, n_player)
print("Sending potato to player", pick)
util.send(pl_socks[pick], potato)
rlist, wlist, xlist = select.select(pl_socks, [], [])
for sock in rlist:
potato = util.recv(sock, Potato)
if potato is not None:
print_trace(potato.trace())
return 0
def run_event_loop(self):
# File descriptor to re-register when waiting
register_fd = None
while True:
event = self.event_queue.wait(register_fd=register_fd,
oneshot=ONESHOT)
register_fd = None
if not event:
logging.error('No events, exiting.')
break
src_fd, event_type = event
# New connection available, accept it
if src_fd == self.listen_sock.fileno():
self.accept()
else:
# Otherwise, we got an event on a tunneled socket
assert src_fd in self.socket_dest
src, dest = self.socket_dest[src_fd]
# Error, disconnect
if event_type == event_queue.ERROR:
self.disconnect(src, dest)
else:
buf = util.recv(src, self.BUF_SIZE)
# Error, disconnect
if not buf:
self.disconnect(src, dest)
# XXX buffer if not writeable? take read fd out of poll set?
elif not util.send(dest, buf):
self.disconnect(src, dest)
# Re-register this file descriptor
elif ONESHOT:
register_fd = src_fd
def main(socket_serv):
socket_serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
socket_serv.bind((HOST, PORT))
socket_serv.listen()
sock, addr = socket_serv.accept()
try:
print("Connected by", addr)
while True:
command = util.recv(sock)
command = util.split_command(command)
if command[0] == "exit":
break
elif command[0] == "download":
filename = command[1]
file_transfer.upload_file(sock, BASEPATH, filename)
elif command[0] == "upload":
filename = command[1]
file_transfer.download_file(sock, BASEPATH, filename)
elif command[0] == "sync":
pass
else:
toret = execute_command(command) or "Invalid command!"
util.send(sock, toret)
finally:
sock.close()
def run(self):
"""This is what the main server thread runs."""
while True:
try:
# accept and receive socket message
s, addr = self.ss.accept()
self.server_started = True
msg = recv(s)
# verify message information
if not self.verify_message(msg):
eprint(self.name, 'Error processing ' + str(msg) + '.')
s.close()
continue
msg_head, *msg_args = msg
# respond to received message
if msg_head in Constants.OPEN_SOCKET:
Thread(target=self.respond[msg_head],
args=(s, msg_args)).start()
else:
Thread(target=self.respond[msg_head],
args=(msg_args, )).start()
except Exception:
traceback.print_exc()
def start_server(self, ss):
while True:
try:
# accept and receive socket message
s, addr = ss.accept()
msg = recv(s)
# verify message information
if not self.verify_message(msg):
eprint(self.name, 'Error processing message.')
continue
msg_head, *msg_args = msg
# respond to received message
if msg_head in Constants.OPEN_SOCKET:
if not self.respond[msg_head](s, msg_args):
break
else:
if not self.respond[msg_head](msg_args):
break
if msg_head == Constants.SHUFFLE:
break
except ConnectionAbortedError:
print()
ss.close()
break
except Exception:
traceback.print_exc()
ss.close()
self.listening = False
def _verify_simple(sock,
Gamma,
R,
S,
g=Constants.G,
p=Constants.P,
q=Constants.Q):
assert (len(R) == len(S))
n = len(R)
# step 1
t = randkey(0, q - 1)
send(sock, t)
# step 2
Theta = recv(sock)
# step 3
c = randkey(0, q - 1)
send(sock, c)
# step 4
alpha = recv(sock)
# step 5
U = powm(g, -t % q, p)
W = powm(Gamma, -t % q, p)
R_hat = [(R[i] * U) % p for i in range(n)]
S_hat = [(S[i] * W) % p for i in range(n)]
ret = True
for i in range(2 * n):
if i < n:
ver = powm(R_hat[i], alpha[i], p) * powm(S_hat[i],
-alpha[i + 1] % q, p)
ver %= p
ret = ret and (Theta[i] == ver)
else:
ver = powm(Gamma, alpha[i], p) * powm(
g, -alpha[(i + 1) % (2 * n)] % q, p)
ver %= p
ret = ret and (Theta[i] == ver)
return ret
def accept(self):
(src, src_address) = self.listen_sock.accept()
# Confirm protocol
version = util.recv(src, 4)
assert version == b'zlbs', version
# Receive destination address
domain = util.recv_str(src).decode('ascii')
port = util.recv(src, '!H')
dest_address = (domain, port)
# Connect to the desired domain/port
dest = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
dest.connect(dest_address)
# Bi-directionally connect the client socket and the destination socket
# so we can mirror traffic back and forth
self.connect(src, src_address, dest, dest_address)
def sync(self, sock):
util.send(sock, "ls -l")
remote_data = util.recv(sock)
remote_data = json.loads(remote_data)
client_data = commands.ls(self.basedir, long=True)
client_data = json.loads(client_data)
client_filelist = list(map(lambda f: f["name"], client_data))
remote_filelist = list(map(lambda f: f["name"], remote_data))
cue_download = []
cue_upload = []
for file in remote_data:
if file["name"] not in client_filelist:
cue_download.append(file["name"])
for file in client_data:
if file["name"] not in remote_filelist:
cue_upload.append(file["name"])
for file in remote_data:
if not file["name"] in client_filelist:
continue
# do not request hash if file was modified before previous sync
if file['name'] in self.last_synced and file["mtime"] < self.last_synced[file['name']]:
continue
util.send(sock, f"hash {file['name']}")
hsh = util.recv(sock)
local_hsh = util.hashfile(os.path.join(self.basedir, file['name']))
if hsh != local_hsh: # IMPORTANT LOGIC
local_file = [f for f in client_data if f.get('name')== f['name']][0]
if file['mtime'] > local_file['mtime']:
# server updated file after client
cue_download.append(file['name'])
else:
# client updated dile after server
cue_upload.append(file['name'])
else: # mtime differs but file is in sync as compared by hash
self.last_synced[file['name']] = time.time()
for filename in cue_upload:
util.send(sock, f"upload {filename}")
file_transfer.upload_file(sock, self.basedir, filename)
self.last_synced[filename] = time.time()
for filename in cue_download:
util.send(sock, f"download {filename}")
file_transfer.download_file(sock, self.basedir, filename)
self.last_synced[filename] = time.time()
def run(self): while True: s, addr = self.ss.accept() try: # accept and receive socket message msg = recv(s) # displaying a board can be done at any time if len(msg) > 0 and msg[0] == Constants.DISP_BOARD: self.board.process_message(s, msg, self.phase) continue if self.phase not in [Constants.REGISTRATION_PHASE, Constants.ANNOUNCEMENT_PHASE]: self.board.process_message(s, msg, self.phase) continue # verify message information if not self.verify_message(msg): eprint(self.name, 'Error processing ' + str(msg) + '.') continue msg_head, *msg_args = msg # respond to received message if msg_head in Constants.OPEN_SOCKET: self.respond[msg_head](s, msg_args) else: self.respond[msg_head](msg_args) except ConnectionAbortedError: print() self.ss.close() break except Exception: traceback.print_exc() finally: s.close() self.ss.close()
def prove(sock,
elts_pre,
elts_post,
pi,
beta,
g_,
h_,
g=Constants.G,
p=Constants.P,
q=Constants.Q):
"""Generate a zero-knowledge proof for the verifiable shuffle.
sock: Socket to send messages through
elts_pre: Elements before cryptographic operation
elts_post: Elements after cryptographic operation
pi: Permutation list
beta, g_, h_: Verifiable shuffle parameters
"""
nym_pre = elts_pre[0]
nym_post = elts_post[0]
XY_pre = elts_pre[1]
XY_post = elts_post[1]
assert (len(nym_pre) == len(nym_post))
assert (len(XY_pre) == len(XY_post))
assert (len(nym_pre) == len(XY_pre))
n = len(nym_pre)
pi_inv = [_ for _ in range(n)]
for i in range(n):
pi_inv[pi[i]] = i
# step 1
a = [randkey(0, q - 1) for _ in range(n)]
u = [randkey(0, q - 1) for _ in range(n)]
w = [randkey(0, q - 1) for _ in range(n)]
tau_0 = randkey(0, q - 1)
gamma = randkey(1, q - 1)
Gamma = powm(g, gamma, p)
A = [powm(g, a[i], p) for i in range(n)]
C = [powm(A[pi[i]], gamma, p) for i in range(n)]
U = [powm(g, u[i], p) for i in range(n)]
W = [powm(g, gamma * w[i], p) for i in range(n)]
Lambda_1 = powm(g_, tau_0 + sum([(w[i] * beta) % q for i in range(n)]), p)
Lambda_2 = powm(h_, tau_0 + sum([(w[i] * beta) % q for i in range(n)]), p)
for i in range(n):
X_i, Y_i = XY_pre[i]
Lambda_1 = (Lambda_1 * powm(X_i, (w[pi_inv[i]] - u[i]) % q, p)) % p
Lambda_2 = (Lambda_2 * powm(Y_i, (w[pi_inv[i]] - u[i]) % q, p)) % p
send(sock, [A, C, U, W, Gamma, Lambda_1, Lambda_2])
# step 2
rho = recv(sock)
# step 3
b = [(rho[i] - u[i]) % q for i in range(n)]
d = [(gamma * b[pi[i]]) % q for i in range(n)]
D = [powm(g, d[i], p) for i in range(n)]
send(sock, D)
# step 4
lam = recv(sock)
# step 5
r = [(a[i] + lam * b[i]) % q for i in range(n)]
s = [(gamma * r[pi[i]]) % q for i in range(n)]
sigma = [(w[i] + b[pi[i]]) % q for i in range(n)]
tau = (-tau_0 + sum([(b[i] * beta) % q for i in range(n)])) % q
send(sock, [tau, sigma])
# step 6
_prove_simple(sock, gamma, r, s, g, p, q)
def download_file(sock, basedir, filename):
num_chunks = int(util.recv(sock))
with open(os.path.join(basedir, filename), 'wb') as f:
for i in range(num_chunks):
print(f"Received chunk {i} of {num_chunks}")
f.write(util.recv_bytes(sock))
def main(self):
self.cli, addr = self.s.accept()
while True:
message = raw_input("Mesajinizi Giriniz : ")
util.send(self.cli, message)
print(util.recv(self.cli))
def main(self):
self.s.connect((self.host, self.port))
while True:
print(util.recv(self.s))
message = raw_input("Cevap ver : ")
util.send(self.s, message)
def verify(sock,
elts_pre,
elts_post,
g_,
h_,
g=Constants.G,
p=Constants.P,
q=Constants.Q):
"""Verify a zero-knowledge proof for the verifiable shuffle.
sock: Socket to send messages through
elts_pre: Elements before cryptographic operation
elts_post: Elements after cryptographic operation
g_, h_: Verifiable shuffle parameters
"""
nym_pre = elts_pre[0]
nym_post = elts_post[0]
XY_pre = elts_pre[1]
XY_post = elts_post[1]
assert (len(nym_pre) == len(nym_post))
assert (len(XY_pre) == len(XY_post))
assert (len(nym_pre) == len(XY_pre))
n = len(nym_pre)
# step 1
A, C, U, W, Gamma, Lambda_1, Lambda_2 = recv(sock)
# step 2
rho = [randkey(0, q - 1) for _ in range(n)]
B = [divide(powm(g, rho[i], p), U[i], p) for i in range(n)]
send(sock, rho)
# step 3
D = recv(sock)
# step 4
lam = randkey(0, q - 1)
send(sock, lam)
# step 5
tau, sigma = recv(sock)
# step 6
R = [(A[i] * powm(B[i], lam, p)) % p for i in range(n)]
S = [(C[i] * powm(D[i], lam, p)) % p for i in range(n)]
ret = _verify_simple(sock, Gamma, R, S, g, p, q)
# step 7
Phi_1 = 1
Phi_2 = 1
for i in range(n):
X_i, Y_i = XY_pre[i]
X_ibar, Y_ibar = XY_post[i]
Phi_1 = (Phi_1 * powm(X_ibar, sigma[i], p) *
powm(X_i, -rho[i] % q, p)) % p
Phi_2 = (Phi_2 * powm(Y_ibar, sigma[i], p) *
powm(Y_i, -rho[i] % q, p)) % p
for i in range(n):
ret = ret and (powm(Gamma, sigma[i], p) == (W[i] * D[i]) % p)
ret = ret and (Phi_1 == (Lambda_1 * powm(g_, tau, p)) % p)
ret = ret and (Phi_2 == (Lambda_2 * powm(h_, tau, p)) % p)
return ret
if __name__ == "__main__":
syncer = Syncer(CLIENT_DIR)
os.makedirs("client_dir", exist_ok=True)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
try:
s.connect((HOST, PORT))
while True:
print("prompt>", end=" ")
command = input()
command_split = util.split_command(command)
util.send(s, command)
if command.strip() == "exit":
break
elif command_split[0] == "ls":
data = util.recv(s)
data = json.loads(data)
if "-l" in command_split:
print(util.format_table(("name", "type", "size"),
data))
else:
print("\n".join(data))
elif command_split[0] == "download":
filename = command_split[1]
file_transfer.download_file(s, CLIENT_DIR, filename)
elif command_split[0] == "upload":
filename = command_split[1]
file_transfer.upload_file(s, CLIENT_DIR, filename)
elif command_split[0] == "sync":
syncer.sync(s)
else:
