def guess_password(max_length, in_data, known_part): """Iterative brute-force password guessing. Arguments: max_length -- the maximum length of the password (int) in_data -- the encrypted data (numpy array) known_part -- A part of the decoded data which is known (string) returns -- False or the correct guess """ # This is a fairly silly way to do this # Must be changed for longer passwords to avoid running out of RAM # pull all the possible strings guesses = collections.deque(string.printable) while(guesses): cur_guess = guesses.popleft() if(len(cur_guess) > max_length): return False # decrypt and recondtruct the message # decrypt_bytes in here is more useful to split each key for each threads # cuda version """ create an array of decrypted and reconstructed so also reconstruct could be executed in parallel""" if(len(cur_guess) > Messages): # if there are enough key in the list then try to execute them in parallel during the reconstruct phase decrypted = [None] * Messages i = 0 while (i < Messages): decrypted[i] = decrypt_cuda.decrypt_bytes(in_data, cur_guess) # pop another value from the list cur_guess = guesses.popleft() i = i + 1 # call the parallelised version of reconstruct # reconstruct is an array containing all the reconstruct solution for each message reconstructed = decrypt_cuda.reconstruct_secret(decrypted) for j in range(len(reconstructed)): if(try_password(reconstructed[j], known_part)): return cur_guess else: if(len(cur_guess) < max_length): for char in string.printable: guesses.append(cur_guess + char) else: decrypted = decrypt_cuda.decrypt_bytes(in_data, cur_guess) reconstructed_m = reconstruct_secret(decrypted) if(try_password(reconstructed_m, known_part)): return cur_guess else: if(len(cur_guess) < max_length): for char in string.printable: guesses.append(cur_guess + char)
def guess_password(max_length, in_data, known_part): """Iterative brute-force password guessing. Arguments: max_length -- the maximum length of the password (int) in_data -- the encrypted data (numpy array) known_part -- A part of the decoded data which is known (string) returns -- False or the correct guess """ # This is a fairly silly way to do this # Must be changed for longer passwords to avoid running out of RAM # pull all the possible strings guesses = collections.deque(string.printable) while(guesses): cur_guess = guesses.popleft() if(len(cur_guess) > max_length): return False # decrypt and recondtruct the message # decrypt_bytes in here is more useful to split each key for each threads # cuda version decrypted = decrypt_cuda.decrypt_bytes(in_data, cur_guess) # sequential version # decrypted = decrypt_bytes(in_data, cur_guess) reconstructed = reconstruct_secret(decrypted) if(try_password(reconstructed, known_part)): return cur_guess else: if(len(cur_guess) < max_length): for char in string.printable: guesses.append(cur_guess + char)
def guess_password(max_length, in_data, known_part): """Iterative brute-force password guessing. Arguments: max_length -- the maximum length of the password (int) in_data -- the encrypted data (numpy array) known_part -- A part of the decoded data which is known (string) returns -- False or the correct guess """ # This is a fairly silly way to do this # Must be changed for longer passwords to avoid running out of RAM # pull all the possible strings guesses = collections.deque(string.printable) while(guesses): # pop first NUM_KEY guesses if there are any if(len(guesses)<NUM_KEY): cur_guess = guesses.popleft() if(len(cur_guess) > max_length): return False # decrypt and recondtruct the message # decrypt_bytes in here is more useful to split each key for each threads # cuda version decrypted = decrypt_cuda.decrypt_bytes(in_data, cur_guess) # sequential version # decrypted = decrypt_bytes(in_data, cur_guess) reconstructed = reconstruct_secret(decrypted) if(try_password(reconstructed, known_part)): return cur_guess else: if(len(cur_guess) < max_length): for char in string.printable: guesses.append(cur_guess + char) else: # call another parallel class which parallelize also the keys cur_guesses = np.empty(NUM_KEY, dtype=np.uint32) # pop first NUM_KEY elements from guesses i = 0 while (i < NUM_KEY): cur_guesses[i] = guesses.popleft() i = i + 1 # return a list of decrypted messages decrypted_list = decrypt_cuda_v2.decrypt_bytes(in_data, cur_guesses) # in decrypted_list there is a long array made of all the decrypted values from 500 keys. # each len(in_data) position there is a new key #TODO: PROBLEM: HOW DO I RECOGNIZE WHICH KEY IS? according to i number for i in range(len(decrypted_list)/len(in_data)): reconstructed = reconstruct_secret(decrypted_list[(i*len(in_data)):((i+1) * len(in_data))]) if(try_password(reconstructed, known_part)): return cur_guesses[i] else: if(len(cur_guesses[i]) < max_length): for char in string.printable: guesses.append(cur_guesses[i] + char)