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: