def compute_session_key(self, salt, server_B):
'''Calculates client's session key and evidence message.'''
self.session_key = compute_hash(self.premaster_secret)
self.M = compute_M(self.g, self.N, self.username, salt, self.A,
server_B, self.session_key)
self.hashed_AMK = compute_hash(self.A, self.M, self.session_key)
return self.M
def _compute_x(self, salt, username, password):
'''
Computes x according to the RFC formula:
x = SHA1(s | SHA1(I | ":" | P))
'''
separator = b':'
h_up = compute_hash(username, separator, password)
x = compute_hash(salt, h_up)
return int.from_bytes(x, byteorder=DEFAULT_BYTEORDER)
def compute_session_key(self, username, salt, client_A):
'''
Calculates server's session key and evidence message.
M = H(H(N) XOR H(g) | H(U) | s | A | B | K)
H(A | M | K)
'''
self.session_key = compute_hash(self.premaster_secret)
self.M = compute_M(self.g, self.N, username, salt, client_A, self.B,
self.session_key)
self.hashed_AMK = compute_hash(client_A, self.M, self.session_key)
return self.M
def check_partial_torrent():
numb_pieces = len(pieces)
piece_length = my_ordred_dict[b'info'][b'piece length']
if MULTI_FILE:
index = 0
piece = b''
for size, path in files:
if os.path.exists(path):
with open(path, 'r+b') as cur_file:
pointer = 0
if len(piece) > 0:
left_to_piece = piece_length - len(piece)
if left_to_piece < size:
piece += cur_file.read(left_to_piece)
if len(piece) == piece_length:
if utils.compute_hash(piece) == pieces[index]:
downloaded_pieces[index] = 1
index += 1
pointer = left_to_piece
size = size - left_to_piece
piece, index = read_file(cur_file, pointer,
piece_length, size, index)
else:
piece += cur_file.read()
if len(piece) == piece_length:
if utils.compute_hash(piece) == pieces[index]:
downloaded_pieces[index] = 1
index += 1
continue
else:
piece, index = read_file(cur_file, pointer,
piece_length, size, index)
if len(piece) > 0:
if utils.compute_hash(piece) == pieces[index]:
downloaded_pieces[index] = 1
else:
if os.path.exists(save_directory + "/" + file):
with open(save_directory + "/" + file, "r+b") as cur_file:
for i in range(numb_pieces):
cur_file.seek(i * piece_length)
piece = cur_file.read(piece_length)
if utils.compute_hash(piece) == pieces[i]:
downloaded_pieces[i] = 1
async def open(cls, path):
async with aiofiles.open(path, 'rb') as f:
body = await f.read()
return cls(
name=os.path.basename(path),
body=body,
hash_=compute_hash(body + settings.address.encode('utf-8'))
)
def compute_premaster_secret(self, salt, server_B):
'''Calculates client premaster secret'''
server_B = obj_to_int(server_B)
l = self.N.bit_length()
padded_client_A = compute_padding(self.A, l)
padded_server_B = compute_padding(server_B, l)
u = obj_to_int(compute_hash(padded_client_A, padded_server_B))
x = self._compute_x(salt, self.username, self.password)
padded_g = compute_padding(self.g, l)
k = obj_to_int(compute_hash(self.N, padded_g))
t1 = server_B - k * pow(self.g, x, self.N)
t2 = self.a + u * x
self.premaster_secret = pow(t1, t2, self.N)
return self.premaster_secret
def unpack_piece(raw_data, my_pieces, peer_socket, bitfield):
try:
index, begin = struct.unpack('!II', raw_data[:8])
block = raw_data[8:]
my_pieces[index] += block
prev_bytes = my_ordred_dict[b'info'][b'piece length'] * index
#last piece of data
global downloaded_bytes
lock.acquire()
if len(my_pieces[index]
) == my_ordred_dict[b'info'][b'piece length'] or (
(index == len(pieces) - 1
and prev_bytes + len(my_pieces[index]) == full_length)):
lock.release()
if utils.compute_hash(my_pieces[index]) == pieces[index]:
write_block_in_file(my_pieces[index], index, begin)
if sum(downloaded_pieces) != len(pieces):
send_request(bitfield, peer_socket, my_pieces)
return False
else:
return True
else:
with pieces_lock:
try:
downloaded_pieces[index] = 0
except KeyboardInterrupt:
return True
print("hash wasn't correct ")
return True
else:
lock.release()
if index == len(pieces) - 1 and prev_bytes + len(
my_pieces[index]) + PIECE_SIZE > full_length:
last_piece_size = full_length - prev_bytes - len(
my_pieces[index])
if last_piece_size == 0: return False
utils.send_piece_numb(peer_socket=peer_socket,
index=index,
length=last_piece_size,
begin=len(my_pieces[index]))
else:
utils.send_piece_numb(peer_socket=peer_socket,
index=index,
length=PIECE_SIZE,
begin=len(my_pieces[index]))
return False
except:
lock.release()
return True
def compute_server_values(self,
username,
verifier,
byte_size=DEFAULT_SECRETSIZE):
'''Calculates server values'''
l = self.N.bit_length()
self.b = obj_to_int(get_randombytes(byte_size))
k = obj_to_int(compute_hash(self.N, compute_padding(self.g, l)))
self.B = (k * verifier + pow(self.g, self.b, self.N)) % self.N
return self.B
def compute_premaster_secret(self, salt, server_B):
'''
Calculates client premaster secret
u = SHA1(PAD(A) | PAD(B))
k = SHA1(N | PAD(g))
x = SHA1(s | SHA1(I | ":" | P))
<premaster secret> = (B - (k * g^x)) ^ (a + (u * x)) % N
'''
server_B = obj_to_int(server_B)
l = self.N.bit_length()
padded_client_A = compute_padding(self.A, l)
padded_server_B = compute_padding(server_B, l)
u = obj_to_int(compute_hash(padded_client_A, padded_server_B))
x = self._compute_x(salt, self.username, self.password)
padded_g = compute_padding(self.g, l)
k = obj_to_int(compute_hash(self.N, padded_g))
t1 = server_B - k * pow(self.g, x, self.N)
t2 = self.a + u * x
self.premaster_secret = pow(t1, t2, self.N)
return self.premaster_secret
def compute_premaster_secret(self,
username,
salt,
verifier,
client_A,
scs=DEFAULT_SECRETSIZE):
'''Calculates server premaster secret'''
l = self.N.bit_length()
padded_client_A = compute_padding(client_A, l)
padded_server_B = compute_padding(self.B, l)
u = obj_to_int(compute_hash(padded_client_A, padded_server_B))
self.premaster_secret = pow(client_A * pow(verifier, u, self.N),
self.b, self.N)
return self.premaster_secret
def read_file(cur_file, pointer, piece_length, size, index):
piece = b''
while pointer + piece_length < size:
cur_file.seek(pointer)
piece = cur_file.read(piece_length)
if utils.compute_hash(piece) == pieces[index]:
downloaded_pieces[index] = 1
index += 1
pointer += piece_length
if size > 0:
cur_file.seek(pointer)
piece = cur_file.read()
return piece, index
return b'', index
verbose = args.verbose
save_directory = args.directory
logging_time = int(args.t) if args.t else 30
signal.signal(signal.SIGINT, signal_handler)
if not os.path.exists(save_directory) or (not os.path.isdir(save_directory)):
print("No such directory")
exit()
if save_directory == "/":
save_directory = os.getcwd()
my_ordred_dict = bencodepy.decode_from_file(path_torrent_file)
dict_hash = utils.compute_hash(bencodepy.encode(my_ordred_dict[b'info']))
my_peer_id = utils.random_peer_id()
hashes = my_ordred_dict[b'info'][b'pieces']
root_directory = ""
files = []
file = ()
if b'files' in my_ordred_dict[b'info'].keys():
root_directory = str(my_ordred_dict[b'info'][b'name'], 'utf-8')
if root_directory.endswith("/"): root_directory = root_directory[:-1]
# if save_directory.endswith("/"): save_directory = save_directory[:-1]
if not os.path.exists(save_directory + "/" + root_directory):
os.mkdir(save_directory + "/" + root_directory)
def hashify_password(self, password):
self.password = compute_hash(password, self.salt)
def authenticate(self, password):
pass_hash = compute_hash(password, self.salt)
return safe_str_cmp(self.password.encode('utf-8'), pass_hash.encode('utf-8'))
async def compute_chunk_hash(self, from_: int, to_: int) -> str:
body = await self.get_body()
chunk = body[from_:to_]
return compute_hash(chunk)