def gen_commitments(): secret = bytearray(Random.get_random_bytes(16)) rc = hash(secret + b"r") kouho = bytearray(b'r' + bytearray([15]) * 15) rcs = fukugen(rc, kouho) print(rcs) pc = hash(secret + b"p") kouho = bytearray(b'p' + bytearray([15]) * 15) pcs = fukugen(pc, kouho) print(pcs) sc = hash(secret + b"s") kouho = bytearray(b's' + bytearray([15]) * 15) scs = fukugen(sc, kouho) print(scs) secret = hex(bytes_to_int(secret))[2:] print(secret) rps = [("r", rc), ("p", pc), ("s", sc)] print('get random') random.shuffle(rps) print('get random done') return secret, rps
def generate_password(length=16, symbolgroups=DEFAULT_PASSWORD_SYMBOLS): """Generate a random password from the supplied symbol groups. At least one symbol from each group will be included. Unpredictable results if length is less than the number of symbol groups. Believed to be reasonably secure (with a reasonable password length!) """ # NOTE(jerdfelt): Some password policies require at least one character # from each group of symbols, so start off with one random character # from each symbol group password = [random.choice(s) for s in symbolgroups] # If length < len(symbolgroups), the leading characters will only # be from the first length groups. Try our best to not be predictable # by shuffling and then truncating. random.shuffle(password) password = password[:length] length -= len(password) # then fill with random characters from all symbol groups symbols = ''.join(symbolgroups) password.extend([random.choice(symbols) for _i in range(length)]) # finally shuffle to ensure first x characters aren't from a # predictable group random.shuffle(password) return ''.join(password)
def decideAmounts(totalInputs, toSend, Partitions, k, fuzz): #fuzz is an optional amount to fuzz the transaction by #so if you start with a big obvious number like 2000, it might be fuzzed by up to "fuzz" amount fz = rand.randint(0, int(fuzz * 1000) ) / 1000.0 toSend += fz g, ii =frexp10(totalInputs) ii = 10 ** (-1 * min(ii - 2, 0)) print("ii", ii) M = 10 ** (int(math.log(2 ** Partitions) / math.log(10))) * ii #M = 10 ** M print("multiplier:", M) totalInputs = int(totalInputs * M) toSend = int(toSend * M) change = totalInputs - toSend send_amounts, change_amounts = decomposition3(totalInputs, Partitions, toSend, k) all_amounts = send_amounts[:] + change_amounts[:] rand.shuffle(all_amounts) print("") print("change amounts:", divv(change_amounts, M)) print("send amounts:", divv(send_amounts, M)) print("now from the following, how much is sent?") print("all amounts:", sorted(divv(all_amounts, M))) print("possible sent amounts:") amounts = [] for L in range(0, len(all_amounts)+1): for subset in itertools.combinations(all_amounts, L): amounts.append(sum(subset)) print("number of possible sent amounts:") print(len(amounts)) print("2^N:", 2 ** len(all_amounts)) print("number of possible sent amounts duplicates removed:") print(len(list(set(amounts))))
def decideAmounts(totalInputs, toSend, Partitions, k, fuzz): #fuzz is an optional amount to fuzz the transaction by #so if you start with a big obvious number like 2000, it might be fuzzed by up to "fuzz" amount fz = rand.randint(0, int(fuzz * 1000)) / 1000.0 toSend += fz g, ii = frexp10(totalInputs) ii = 10**(-1 * min(ii - 2, 0)) print("ii", ii) M = 10**(int(math.log(2**Partitions) / math.log(10))) * ii #M = 10 ** M print("multiplier:", M) totalInputs = int(totalInputs * M) toSend = int(toSend * M) change = totalInputs - toSend send_amounts, change_amounts = decomposition3(totalInputs, Partitions, toSend, k) all_amounts = send_amounts[:] + change_amounts[:] rand.shuffle(all_amounts) print("") print("change amounts:", divv(change_amounts, M)) print("send amounts:", divv(send_amounts, M)) print("now from the following, how much is sent?") print("all amounts:", sorted(divv(all_amounts, M))) print("possible sent amounts:") amounts = [] for L in range(0, len(all_amounts) + 1): for subset in itertools.combinations(all_amounts, L): amounts.append(sum(subset)) print("number of possible sent amounts:") print(len(amounts)) print("2^N:", 2**len(all_amounts)) print("number of possible sent amounts duplicates removed:") print(len(list(set(amounts))))
def decrypt(self, crypto_list): decrypted_list = [] for crypto_pair in crypto_list: decrypted_pair = [self.key._decrypt(c) for c in crypto_pair] decrypted_list.append(decrypted_pair) random.shuffle(decrypted_list) return decrypted_list
def decrypt_multi_cipher(self, crypto_list, pub_keys): p = int(self.key.p) g = int(self.key.g) x = int(self.key.x) while 1: k = random.randint(1, p - 1) if GCD(k, p - 1) == 1: break decrypted_list = [] for cipher_pair in crypto_list: decrypted_pair = [] for c in cipher_pair: c1 = int(c[0]) c2 = int(c[1]) c1_ = (c1 * pow(g, k, p)) % p prod = 1 for y in pub_keys: y = int(y) prod *= pow(y, k, p) prod %= p c1_pow = pow(c1, x, p) c2_ = (((c2 * prod) % p) * inverse(c1_pow, p)) % p decrypted_pair.append((c1_, c2_)) decrypted_list.append(decrypted_pair) random.shuffle(decrypted_list) return decrypted_list
def classical_garble(self): """ The most simple type of garbling. In classical garbled circuits, the whole boolean table is obfuscated by encrypting the output label using the input labels as keys. After this the table is shuffled (or *garbled*) so that the evaluator can't know more than one output label. For more information see `the paper <https://dl.acm.org/citation.cfm?id=1382944>`_. Note that a *Fernet* scheme is used since this method relies on knowing whether decryption was successful or not, as the evaluator needs to try and decrypt the four possible entries in the boolean table. """ for left_label in self.left_wire.labels(): for right_label in self.right_wire.labels(): key1 = Fernet(left_label.to_base64()) key2 = Fernet(right_label.to_base64()) in1, in2 = left_label.represents, right_label.represents logic_value = self.evaluate_gate(in1, in2) output_label = self.output_wire.get_label(logic_value) pickled = pickle.dumps(output_label) table_entry = key1.encrypt(key2.encrypt(pickled)) self.table.append(table_entry) shuffle(self.table)
def pick_files(self): """Pick a random subset of filenames in the Pool and return them as a list. If the Pool isn't sufficiently large, return an empty list. """ poolfiles = os.listdir(self.pooldir) poolsize = len(poolfiles) log.debug("Pool contains %s messages", poolsize) if poolsize < self.size: # The pool is too small to send messages. log.info("Pool is insufficiently populated to trigger sending.") return [] process_num = (poolsize * self.rate) / 100 log.debug("Attempting to send %s messages from the pool.", process_num) assert process_num <= poolsize # Shuffle the poolfiles into a random order random.shuffle(poolfiles) # Even though the list is shuffled, we'll pick a random point in the # list to slice from/to. It does no harm, might do some good and # doesn't cost a lot! startmax = poolsize - process_num if startmax <= 0: return poolfiles start = random.randint(0, startmax - 1) end = start + process_num return poolfiles[start:end]
def build_index(MK, ID, keyword_list): secure_index = [0] * len(keyword_list) for i in range(len(keyword_list)): codeword = build_codeword(ID, build_trapdoor(MK, keyword_list[i])) secure_index[i] = codeword random.shuffle(secure_index) return secure_index
def garble(self): self.output_table = {} self.garbled_table = {} # emptying tables for gate in self.circuit.G.values(): if not gate.is_circuit_output: k_0 = AES_key() # generate a random aes key k_1 = AES_key() # same self.output_table[gate.gate_id] = k_0, k_1 for gate in self.circuit.G.values(): if not gate.is_circuit_input: gate_0 = gate.gate_0 gate_1 = gate.gate_1 K_0 = self.output_table[gate_0.gate_id] # K_0 = k_00, k_01 K_1 = self.output_table[gate_1.gate_id] # K_1 = k_10, k_11 c_list = [] for i in range(2): for j in range(2): alpha = gate.loc_eval( i, j) # 'real' evaluation of the gate on i,j if gate.is_circuit_output: m = alpha # 0 or 1 else: K = self.output_table[gate.gate_id] m = K[alpha].rep_AES_str # k_0 or k_1 (see above) c = K_1[j].encrypt(m) c_ij = K_0[i].encrypt(c) c_list.append(c_ij) random.shuffle(c_list) self.garbled_table[gate.gate_id] = c_list return self.garbled_table
def init_from_build_info(cls, build_key, usability): boffset = 0 api_host = None if build_key in ('Dropbox', 'DropboxTeam') and not usability: host = 'www.dropbox.com' api_host = [ ('client%d.dropbox.com' % i, 443) for i in xrange(100) ] random.shuffle(api_host) elif build_key.startswith('DropboxDev'): host = 'tarak.corp.dropbox.com' boffset -= 100 elif build_key.startswith('DropboxAPI'): host = 'will-meta.getdropbox.com' elif build_key.startswith('DropboxBuild'): host = 'www.dropbox.com' elif build_key.startswith('DropboxId3'): host = os.getenv('DROPBOX_HOST') if not host: host = 'musicbox.corp.getdropbox.com' else: host = os.getenv('DROPBOX_HOST') if not host: host = 'www.dropbox.com' if not api_host: api_host = [(host, 443)] if build_key[-1].isdigit(): p2p_port = 17501 + int(build_key[-1]) + boffset else: p2p_port = 17500 + boffset discovery_port = p2p_port port = 443 toret = cls(host, port, discovery_port, p2p_port) toret.api_hosts = api_host return toret
def __init__(self): self.shipgirls = [ "Aulick", "Beagle", "Benson", "Bulldog", "Cassin", "Comet", "Craven", "Crescent", "Cygnet", "Downes", "Foote", "Foxhound", "Kisaragi", "McCall", "Mikazuki", "Minazuki", "Mutsuki", "Shiranui", "Spence", "Uzuki", "Z20", "Z21", "Acasta", "Akatsuki", "Amazon", "Arashio", "Ardent", "Ariake", "Asashio", "Aylwin", "Bache", "Bailey", "Bush", "Dewey", "Echo", "Fletcher", "Forbin", "Fortune", "Fumizuki", "Gridley", "Halsey Powell", "Hamakaze", "Hammann", "Hatakaze", "Hatsuharu", "Hatsushimo", "Hazelwood", "Hobby", "Ikazuchi", "Inazuma", "Isokaze", "Jenkins", "Jersey", "Juno", "Jupiter", "Kagerou", "Kalk", "Kamikaze", "Kimberly", "Kiyonami", "Kuroshio", "Le Mars", "Matsukaze", "Michishio", "Mullany", "Nagatsuki", "Ooshio", "Oyashio", "Radford", "San Juan", "Shiratsuyu", "Sims", "Smalley", "Stanly", "Tanikaze", "Thatcher", "Urakaze", "Wakaba", "Yuugure", "Z18", "Z19", "Z36", "An Shan", "Ayanami", "Carabiniere", "Chang Chun", "Charles Ausburne", "Cooper", "Fu Shun", "Fubuki", "Glowworm", "Grenville", "Grozny", "Hanazuki", "Harutsuki", "Hibiki", "Javelin", "Kasumi", "L Opiniatre", "Laffey", "Le Temeraire", "Makinami", "Matchless", "Maury", "Minsk", "Musketeer", "Naganami", "Nicholas", "Niizuki", "Nowaki", "Shigure", "Tai Yuan", "Tartu", "Universal Bulin", "Uranami", "Vampire", "Vauquelin", "Yoizuki", "Z1", "Z23", "Z25", "Z35", "Eldridge", "Kawakaze", "Le Malin", "Le Triomphant", "Prototype Bulin MKII", "Tashkent", "Yudachi", "Yukikaze", "Z46" ] random.shuffle(self.shipgirls) self.lcg = LCG(len(self.shipgirls)) self.counter = 0
def alert_players_have_been_ordered(self): if self.peer_map.get(self.cli.ident).get(self.ROLL) == 0: # This is player 0, initiate the shuffle pl = self.gen_playerlist() shuffle(pl) self.cli.post_message(data={self.MESSAGE_KEY: self.SHUFFLED_LIST, self.SHUFFLED_LIST: pl})
def step_5_12(self, rx_enc): c_list = [] if (self.delta == 0): c0_enc = 1 for i in range(self.l): c0_enc *= self.crypto.secure_addition(c0_enc, rx_enc[i]) bl = random.randint(1, 2**self.l) c0 = self.crypto.secure_scalar_multiplication(c0_enc, bl) c_list.append(c0) for i in range(1, self.l): randomint = random.randint(1, 2**self.l) randomint_enc = self.crypto.encrypt(randomint) c_list.append(randomint_enc) else: enc_minus1 = self.crypto.encrypt(self.crypto.n - 1) for i in range(self.l): prod = 1 for j in range(i + 1, self.l): prod *= self.crypto.secure_addition(prod, rx_enc[j]) prod_sq = self.crypto.secure_scalar_multiplication(prod, 2) c_i_1 = self.crypto.secure_addition(enc_minus1, rx_enc[i]) c_i_2 = self.crypto.secure_addition(c_i_1, prod_sq) randomint = random.randint(1, 2**self.l) c_i_fin = self.crypto.secure_scalar_multiplication( c_i_2, randomint) c_list.append(c_i_fin) random.shuffle(c_list) return c_list
def rstr(self, alphabet, start_range=None, end_range=None, include='', exclude=''): """Generate a random string containing elements from 'alphabet' By default, rstr() will return a string between 1 and 10 characters. You can specify a second argument to get an exact length of string. If you want a string in a range of lengths, specify the start and end of that range as the second and third arguments. If you want to make certain that particular characters appear in the generated string, specify them as "include". If you want to *prevent* certain characters from appearing, pass them as 'exclude'. """ popul = [char for char in list(alphabet) if char not in list(exclude)] if end_range is None: if start_range is None: start_range, end_range = (1, 10) else: k = start_range if end_range: k = random.randint(start_range, end_range) result = sample_wr(popul, k) + list(include) random.shuffle(result) return ''.join(result)
def shuffleAddresses(addresses): """ Create a shuffled copy (only references!) of the encrypted output addresses. """ indices = [i for i in xrange(0, len(addresses))] random.shuffle(indices) result = [] for index in indices: result.append(addresses[index]) return result
def __init__(self, input_wires, output_wire, logic_function): self.input_wires, self.output_wire, self.rows = input_wires, output_wire, [] for entry in product(*map(enumerate, input_wires)): function_parameters = [x[0] for x in entry] input_labels = [x[1] for x in entry] function_value = logic_function(*function_parameters) output_label = self.output_wire.labels[function_value] self.rows.append(Gate.crypt_row(output_label, input_labels)) shuffle(self.rows)
def cutChromosome(cuttingPlace, chromosome): result = [] pieces = chromosome.split(cuttingPlace) for piece in pieces[:-1]: result.append(piece + cuttingPlace) if pieces[-1]: result.append(pieces[-1]) random.shuffle(result) return result
def gen_commitments(): secret = bytearray(Random.get_random_bytes(16)) rc = hash(secret + b"r") pc = hash(secret + b"p") sc = hash(secret + b"s") secret = hex(bytes_to_int(secret))[2:] rps = [("r", rc), ("p", pc), ("s", sc)] random.shuffle(rps) return secret, rps
def build_index(MK, ID, keyword_list): # build index for the given input file secure_index = [0] * len(keyword_list) for item in range(len(keyword_list)): codeword = gen_codeword(ID, gen_trapdoor(MK, keyword_list[item])) secure_index[item] = codeword random.shuffle(secure_index) return secure_index
def shuffle_headers(request_text): lines = request_text.split('\r\n') method = lines[:1] headers = lines[1:4] ending = lines[4:] # shuffle headers random.shuffle(headers) return "\r\n".join(method + headers + ending)
def get_unique_languages(self): """ Returns a shuffled list of languages that the user speaks, without repetition """ if hasattr(self, 'unique_langs'): unique_langs = self.unique_langs else: unique_langs = list(set(self.db_csv_to_array('lang_str'))) random.shuffle(unique_langs) return unique_langs
def generate_password(range=None, size=16): if not range: range = string.digits + string.ascii_letters + string.digits a = [] while len(a) < size - 4: a.append(random.choice(range)) while len(a) < size - 2: a.append(random.choice(r"+=-@#~,.[]()!%^*$")) random.shuffle(a) return random.choice(string.ascii_letters) + \ ''.join(a) + \ random.choice(string.ascii_letters)
def known_contacts_list(self): """ Return an unordered list of past and present friends' ids. """ known_fids = self.friend_id_list() + \ self.friend_id_list("former") # So that nobody can tell which friends are the most recent ones random.shuffle( known_fids) self.array_to_db_csv("known_contacts_tmp", known_fids) return known_fids
def post(self): args = random_strings_parser.parse_args() n = int(args["length"]) rand_string = [s for s in string.printable] shuffle(rand_string) data = { 'random': ''.join([str(x) for x in rand_string[:n]]) } return jsonify(data)
def password(text, notice): """[length [types]] - generates a password of <length> (default 10). [types] can include 'alpha', 'no caps', 'numeric', 'symbols' or any combination: eg. 'numbers symbols'""" okay = [] # find the length needed for the password numb = text.split(" ") try: length = int(numb[0]) except ValueError: length = 12 if length > 50: notice("Maximum length is 50 characters.") return # add alpha characters if "alpha" in text or "letter" in text: okay += list(string.ascii_lowercase) # adds capital characters if not told not to if "no caps" not in text: okay += list(string.ascii_uppercase) # add numbers if "numeric" in text or "number" in text: okay += list(string.digits) # add symbols if "symbol" in text or "special" in text: sym = [ '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '=', '_', '+', '[', ']', '{', '}', '\\', '|', ';', ':', "'", '.', '>', ',', '<', '/', '?', '`', '~', '"' ] okay += sym # defaults to lowercase alpha + numbers password if the okay list is empty if not okay: okay = list(string.ascii_lowercase) + list(string.digits) # extra random lel random.shuffle(okay) chars = [] for i in range(length): chars.append(random.choice(okay)) notice("".join(chars))
def take_turn(self): self.shuffled_times += 1 if self.is_first_turn(): self.share_primes() self.cli.log(LogLevel.INFO, "Shuffled deck") self.encryptd_by.append(self.cli.ident) self.encrypt_deck() shuffle(self.shuffle_state) self.send_round_message( self.SHUFFLE_DECK, { self.SHUFFLE_DECK: self.shuffle_state, self.ENCRYPTED_BY: self.encryptd_by }) self.end_my_turn()
def next_batch(self, batch_size): """Return the next `batch_size` examples from this data set.""" start = self.index_in_epoch_ if start == 0: shuffle(self.objects_) end = int(self.num_examples_ - 1) self.index_in_epoch_ += batch_size if self.index_in_epoch_ >= self.num_examples: #Finished epoch self.epochs_completed_ += 1 self.index_in_epoch_ = 0 else: end = int(self.index_in_epoch_) return self.read_input_and_label(start, end)
def keyGen( ): # creates the public and private keys and stores them in puKey and piKey reset = 1 # will be used to test if any part of the keygen brakes and start over reset2 = 1 reset3 = 1 while reset or reset2 or reset3: # used to prevent errors by regenerating keys if needed. was more useful when collisions were more likely minSize = 0 for k in range(0, keyLength): # generate the super increasing sequence temp = random.randint( minSize, (minSize * 2) + 100 ) # the minsize *2 +100 max is to prevent the first int and others from being to big piKey.supSeq[k] = temp minSize += temp piKey.M = random.randint(minSize, (minSize * 3)) # create M # test the super increasing sequence hold = 0 reset = 0 for L in range(0, keyLength): if piKey.supSeq[L] < hold: reset = 1 else: hold += piKey.supSeq[L] reset2 = 1 for _ in itertools.count( 1 ): #create W # uses iteratools because number of loops was to big piKey.W = random.randint(1, piKey.M + 1) if fractions.gcd(piKey.M, piKey.W) == 1: #test W reset2 = 0 break reset3 = 1 if (1 < piKey.W) and (piKey.W < (piKey.M + 1)): reset3 = 0 for i in range(0, keyLength): # generate sequence permutation piKey.perSeq[i] = i random.shuffle(piKey.perSeq) for j in range(0, keyLength): #generate public key puKey[j] = (piKey.W * piKey.supSeq[piKey.perSeq[j] - 1]) % piKey.M
def password(text, notice): """[length [types]] - generates a password of <length> (default 10). [types] can include 'alpha', 'no caps', 'numeric', 'symbols' or any combination: eg. 'numbers symbols'""" okay = [] # find the length needed for the password numb = text.split(" ") try: length = int(numb[0]) except ValueError: length = 12 if length > 50: notice("Maximum length is 50 characters.") return # add alpha characters if "alpha" in text or "letter" in text: okay += list(string.ascii_lowercase) # adds capital characters if not told not to if "no caps" not in text: okay += list(string.ascii_uppercase) # add numbers if "numeric" in text or "number" in text: okay += list(string.digits) # add symbols if "symbol" in text or "special" in text: sym = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '=', '_', '+', '[', ']', '{', '}', '\\', '|', ';', ':', "'", '.', '>', ',', '<', '/', '?', '`', '~', '"'] okay += sym # defaults to lowercase alpha + numbers password if the okay list is empty if not okay: okay = list(string.ascii_lowercase) + list(string.digits) # extra random lel random.shuffle(okay) chars = [] for i in range(length): chars.append(random.choice(okay)) notice("".join(chars))
def main(): # Normalize arguments args = docopt(__doc__) word_count = int(args["--length"]) # Read and transform dictionary file if args["--dictionary"]: dict_path = args["--dictionary"] else: dict_path = os.path.join(os.path.dirname(__file__), "words.txt") dictionary = [w for w in [l.strip() for l in open(dict_path)] if w] if args["--truncate"]: dictionary = dictionary[: int(args["--truncate"])] elif not args["--dictionary"]: # Default truncation for built-in dictionary dictionary = dictionary[:8192] # Basic entropy calculation if args["--uncontrolled"]: entropy = math.log(math.pow(len(dictionary), word_count), 2) else: batch_size = len(dictionary) // word_count entropy = math.log(math.pow(batch_size, word_count) * math.factorial(word_count), 2) if args["--verbose"]: print("Pessimistic password entropy: %.1f bits" % entropy) print("Approximate time to crack at 20k/s: %.1f days" % (math.pow(2, entropy) / 20000 / 60 / 60 / 24)) # Generate password if args["--uncontrolled"]: # Select random words words = [random.choice(dictionary) for i in range(word_count)] else: # Generate batches in random order batches = [dictionary[i * batch_size : (i + 1) * batch_size] for i in range(word_count)] random.shuffle(batches) # Select word from each batch words = [random.choice(batches[i]) for i in range(word_count)] # Reveal to user print(" ".join(words)) if args["--complex"]: print("Complexified: %s1." % "".join(words).capitalize())
def select_subset(self): """Pick a random subset of filenames in the Pool and return them as a list. If the Pool isn't sufficiently large, return an empty list. """ files = os.listdir(self.pooldir) numfiles = len(files) if numfiles > 0: self.log.debug("Pool contains %s messages", numfiles) if numfiles < self.size: # The pool is too small to send messages. self.log.debug("Pool is insufficiently populated to trigger " "sending.") files = [] numfiles = 0 # Without adding the 0.5, a queue containing one message will never # send that message. process_num = int(numfiles * float(self.rate) / 100 + 0.5) if process_num > 0: self.log.debug("Attempting to send %s messages from the pool.", process_num) assert process_num <= numfiles # Shuffle the poolfiles into a random order random.shuffle(files) # Even though the list is shuffled, pick a random point in the list to # slice from/to. It does no harm, might do some good and doesn't cost # a lot! startmax = numfiles - process_num if startmax == 0: start = 0 else: start = random.randint(0, startmax - 1) end = start + process_num for f in files[start:end]: yield os.path.join(self.pooldir, f) self.processed += process_num # Set the point in the future at which another outbound pool run will # occur. self.trigger_time = timing.dhms_future(self.interval) self.log.debug("Next pool run: %s", timing.timestamp(self.trigger_time))
def get_global_langs_needed(self): """ Returns an unordered list with repetitions of the languages that the user's new global friends should speak """ tokens = self.db_csv_to_array('global_token_str') langs = self.db_csv_to_array('lang_str') need = [] # Some people may have lost their lang_str for some reason. # Corrupted data etc. if len(langs) == 0: langs = ["en"] * getattr(self, "NUM_REMOTE_FRIENDS", 6) for i, lang in enumerate(tokens): if lang == "0": try: need.append(langs[i]) except IndexError: need.append(langs[0]) random.shuffle(need) self.array_to_db_csv("global_langs_tmp", need) return need
def gm_eval_honest(number1, cipher2, pub_key2): assert(len(cipher2) == INT_LEN) n = pub_key2 cipher1 = encrypt_gm(number1, n) neg_cipher1 = map(lambda x: x * (n-1) % n, cipher1) c_neg_xor = dot_mod(neg_cipher1, cipher2, n) cipher1_and = embed_and(cipher1, pub_key2) cipher2_and = embed_and(cipher2, pub_key2) neg_cipher1_and = embed_and(neg_cipher1, pub_key2) c_neg_xor_and = embed_and(c_neg_xor, pub_key2) res = [ ] for l in range(INT_LEN): temp = dot_mod(cipher2_and[l], neg_cipher1_and[l], n) for u in range(l): temp = dot_mod(temp, c_neg_xor_and[u], n) res.append(temp) random.shuffle(res) return res
def symbol_insert(self, passphrase): # list of symbols to choose from symbol_list = [ '!', '@', '#', '$', '%', '^', '&' '*', '(', ')', '+', '=', '_' ] # define the amount of symbols to use in a given string based on length >= 8 symbol_count = round(len(passphrase) / 4) count = 0 while count < symbol_count: # pick random symbols based on int chosen and append it to passphrase rand_int = random.randrange(0, len(symbol_list)) passphrase += symbol_list[rand_int] count += 1 passphrase = [ char for char in passphrase ] # no delimiter, no .split(). list comprehension to split characters random.shuffle( passphrase) # Pycrypdome shuffle, shuffle the list elements around passphrase = ''.join( passphrase) # rejoin the list into the passphrase string return passphrase
def runTest(self): """Crypto.Random.new()""" # Import the Random module and try to use it from Crypto import Random randobj = Random.new() x = randobj.read(16) y = randobj.read(16) self.assertNotEqual(x, y) z = Random.get_random_bytes(16) self.assertNotEqual(x, z) self.assertNotEqual(y, z) # Test the Random.random module, which # implements a subset of Python's random API # Not implemented: # seed(), getstate(), setstate(), jumpahead() # random(), uniform(), triangular(), betavariate() # expovariate(), gammavariate(), gauss(), # longnormvariate(), normalvariate(), # vonmisesvariate(), paretovariate() # weibullvariate() # WichmannHill(), whseed(), SystemRandom() from Crypto.Random import random x = random.getrandbits(16*8) y = random.getrandbits(16*8) self.assertNotEqual(x, y) # Test randrange if x>y: start = y stop = x else: start = x stop = y for step in range(1,10): x = random.randrange(start,stop,step) y = random.randrange(start,stop,step) self.assertNotEqual(x, y) self.assertEqual(start <= x < stop, True) self.assertEqual(start <= y < stop, True) self.assertEqual((x - start) % step, 0) self.assertEqual((y - start) % step, 0) for i in range(10): self.assertEqual(random.randrange(1,2), 1) self.assertRaises(ValueError, random.randrange, start, start) self.assertRaises(ValueError, random.randrange, stop, start, step) self.assertRaises(TypeError, random.randrange, start, stop, step, step) self.assertRaises(TypeError, random.randrange, start, stop, "1") self.assertRaises(TypeError, random.randrange, "1", stop, step) self.assertRaises(TypeError, random.randrange, 1, "2", step) self.assertRaises(ValueError, random.randrange, start, stop, 0) # Test randint x = random.randint(start,stop) y = random.randint(start,stop) self.assertNotEqual(x, y) self.assertEqual(start <= x <= stop, True) self.assertEqual(start <= y <= stop, True) for i in range(10): self.assertEqual(random.randint(1,1), 1) self.assertRaises(ValueError, random.randint, stop, start) self.assertRaises(TypeError, random.randint, start, stop, step) self.assertRaises(TypeError, random.randint, "1", stop) self.assertRaises(TypeError, random.randint, 1, "2") # Test choice seq = list(range(10000)) x = random.choice(seq) y = random.choice(seq) self.assertNotEqual(x, y) self.assertEqual(x in seq, True) self.assertEqual(y in seq, True) for i in range(10): self.assertEqual(random.choice((1,2,3)) in (1,2,3), True) self.assertEqual(random.choice([1,2,3]) in [1,2,3], True) if sys.version_info[0] is 3: self.assertEqual(random.choice(bytearray(b('123'))) in bytearray(b('123')), True) self.assertEqual(1, random.choice([1])) self.assertRaises(IndexError, random.choice, []) self.assertRaises(TypeError, random.choice, 1) # Test shuffle. Lacks random parameter to specify function. # Make copies of seq seq = list(range(500)) x = list(seq) y = list(seq) random.shuffle(x) random.shuffle(y) self.assertNotEqual(x, y) self.assertEqual(len(seq), len(x)) self.assertEqual(len(seq), len(y)) for i in range(len(seq)): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) self.assertEqual(seq[i] in x, True) self.assertEqual(seq[i] in y, True) z = [1] random.shuffle(z) self.assertEqual(z, [1]) if sys.version_info[0] == 3: z = bytearray(b('12')) random.shuffle(z) self.assertEqual(b('1') in z, True) self.assertRaises(TypeError, random.shuffle, b('12')) self.assertRaises(TypeError, random.shuffle, 1) self.assertRaises(TypeError, random.shuffle, "1") self.assertRaises(TypeError, random.shuffle, (1,2)) # 2to3 wraps a list() around it, alas - but I want to shoot # myself in the foot here! :D # if sys.version_info[0] == 3: # self.assertRaises(TypeError, random.shuffle, range(3)) # Test sample x = random.sample(seq, 20) y = random.sample(seq, 20) self.assertNotEqual(x, y) for i in range(20): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) z = random.sample([1], 1) self.assertEqual(z, [1]) z = random.sample((1,2,3), 1) self.assertEqual(z[0] in (1,2,3), True) z = random.sample("123", 1) self.assertEqual(z[0] in "123", True) z = random.sample(list(range(3)), 1) self.assertEqual(z[0] in range(3), True) if sys.version_info[0] == 3: z = random.sample(b("123"), 1) self.assertEqual(z[0] in b("123"), True) z = random.sample(bytearray(b("123")), 1) self.assertEqual(z[0] in bytearray(b("123")), True) self.assertRaises(TypeError, random.sample, 1)
def generate_key(alpha): copy = list(alpha) random.shuffle(copy) return tuple(copy)
def shuffle(self): '''Creates a new deck and uses PyCrypto to shuffle it.''' self.deck = range(52) shuffle(self.deck) return
def runTest(self): """Crypto.Random.new()""" # Import the Random module and try to use it from Crypto import Random randobj = Random.new() x = randobj.read(16) y = randobj.read(16) self.assertNotEqual(x, y) z = Random.get_random_bytes(16) self.assertNotEqual(x, z) self.assertNotEqual(y, z) # Test the Random.random module, which # implements a subset of Python's random API # Not implemented: # seed(), getstate(), setstate(), jumpahead() # random(), uniform(), triangular(), betavariate() # expovariate(), gammavariate(), gauss(), # longnormvariate(), normalvariate(), # vonmisesvariate(), paretovariate() # weibullvariate() # WichmannHill(), whseed(), SystemRandom() from Crypto.Random import random x = random.getrandbits(16 * 8) y = random.getrandbits(16 * 8) self.assertNotEqual(x, y) # Test randrange if x > y: start = y stop = x else: start = x stop = y for step in range(1, 10): x = random.randrange(start, stop, step) y = random.randrange(start, stop, step) self.assertNotEqual(x, y) self.assertEqual(start <= x < stop, True) self.assertEqual(start <= y < stop, True) self.assertEqual((x - start) % step, 0) self.assertEqual((y - start) % step, 0) for i in range(10): self.assertEqual(random.randrange(1, 2), 1) self.assertRaises(ValueError, random.randrange, start, start) self.assertRaises(ValueError, random.randrange, stop, start, step) self.assertRaises(TypeError, random.randrange, start, stop, step, step) self.assertRaises(TypeError, random.randrange, start, stop, "1") self.assertRaises(TypeError, random.randrange, "1", stop, step) self.assertRaises(TypeError, random.randrange, 1, "2", step) self.assertRaises(ValueError, random.randrange, start, stop, 0) # Test randint x = random.randint(start, stop) y = random.randint(start, stop) self.assertNotEqual(x, y) self.assertEqual(start <= x <= stop, True) self.assertEqual(start <= y <= stop, True) for i in range(10): self.assertEqual(random.randint(1, 1), 1) self.assertRaises(ValueError, random.randint, stop, start) self.assertRaises(TypeError, random.randint, start, stop, step) self.assertRaises(TypeError, random.randint, "1", stop) self.assertRaises(TypeError, random.randint, 1, "2") # Test choice seq = list(range(10000)) x = random.choice(seq) y = random.choice(seq) self.assertNotEqual(x, y) self.assertEqual(x in seq, True) self.assertEqual(y in seq, True) for i in range(10): self.assertEqual(random.choice((1, 2, 3)) in (1, 2, 3), True) self.assertEqual(random.choice([1, 2, 3]) in [1, 2, 3], True) if sys.version_info[0] is 3: self.assertEqual( random.choice(bytearray(b('123'))) in bytearray(b('123')), True) self.assertEqual(1, random.choice([1])) self.assertRaises(IndexError, random.choice, []) self.assertRaises(TypeError, random.choice, 1) # Test shuffle. Lacks random parameter to specify function. # Make copies of seq seq = list(range(500)) x = list(seq) y = list(seq) random.shuffle(x) random.shuffle(y) self.assertNotEqual(x, y) self.assertEqual(len(seq), len(x)) self.assertEqual(len(seq), len(y)) for i in range(len(seq)): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) self.assertEqual(seq[i] in x, True) self.assertEqual(seq[i] in y, True) z = [1] random.shuffle(z) self.assertEqual(z, [1]) if sys.version_info[0] == 3: z = bytearray(b('12')) random.shuffle(z) self.assertEqual(b('1') in z, True) self.assertRaises(TypeError, random.shuffle, b('12')) self.assertRaises(TypeError, random.shuffle, 1) self.assertRaises(TypeError, random.shuffle, "1") self.assertRaises(TypeError, random.shuffle, (1, 2)) # 2to3 wraps a list() around it, alas - but I want to shoot # myself in the foot here! :D # if sys.version_info[0] == 3: # self.assertRaises(TypeError, random.shuffle, range(3)) # Test sample x = random.sample(seq, 20) y = random.sample(seq, 20) self.assertNotEqual(x, y) for i in range(20): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) z = random.sample([1], 1) self.assertEqual(z, [1]) z = random.sample((1, 2, 3), 1) self.assertEqual(z[0] in (1, 2, 3), True) z = random.sample("123", 1) self.assertEqual(z[0] in "123", True) z = random.sample(list(range(3)), 1) self.assertEqual(z[0] in range(3), True) if sys.version_info[0] == 3: z = random.sample(b("123"), 1) self.assertEqual(z[0] in b("123"), True) z = random.sample(bytearray(b("123")), 1) self.assertEqual(z[0] in bytearray(b("123")), True) self.assertRaises(TypeError, random.sample, 1)
from Crypto.Random import random print('random.randint: ', random.randint(10, 20)) print('random.randrange: ', random.randrange(10, 20, 2)) print('random.randint: ', random.getrandbits(3)) print('random.choice: ', random.choice([1, 2, 3, 4, 5])) print('random.sample: ', random.sample([1, 2, 3, 4, 5], 3)) list = [1, 2, 3, 4, 5] random.shuffle(list) print('random.shuffle: ', list)
def __init__(self, numofplayer): "Constructor of new faras game" assert numofplayer > 1 and numofplayer <= 17, "Error: must have between 2 and 17 players" self.numofplayer = numofplayer self.deck = getNewDeck() random.shuffle(self.deck)
from Crypto.PublicKey import RSA import binascii # import helper's list helpers_list = [] with open("santa.pub", "r") as f: for line in f: helper = line.split("\t") helper_name = helper[0] helper_key = RSA.importKey(helper[1]) helpers_list.append((helper_name, helper_key)) # create santa's suffled list santas_list = [helper[0] for helper in helpers_list] while True: random.shuffle(santas_list) santas_choice = dict(zip(santas_list, helpers_list)) # skip x gives to x if reduce(lambda x, y: x or (y[0] == y[1][0]), santas_choice.items(), False): continue # skip x give to y and y gives to x if reduce(lambda x, y: x or (y[0] == santas_choice[y[1][0]][0]), santas_choice.items(), False): continue break max_name_len = reduce(lambda x, y: y if x < y else x, [len(helper[0]) for helper in helpers_list], 0) for choice in santas_choice.items(): helper_name = choice[1][0] helper_key = choice[1][1] secret_name = choice[0] secret_msg = "Mosul a decis sa iei un cadou pentru %*s. Urmeaza un numar aleator secret %32x." % (
def garble_circuit(circuit, myinputs): """Garble a circuit :param circuit: circuit to garble :type circuit: logic_circuit.Circuit :param myinputs: already known inputs, to be hidden :type myinputs: dictionnary {gate_id: 0/1} :return: Garbled circuit, ungarbling keys associated to myinputs and OT senders for other inputs. :rtype: (garbled_table, input_keys, ot_senders) - garbled_table: dictionnary {gate_id: 4*[AES_key]} - input_keys: dictionnary {input_gate_id: AES_key} - ot_senders: dictionnary {input_gate_id: OT.Sender} """ # @students: What are the key steps in this function that make it such that # the inputs of Alice are not revealed to Bob ? # Garbling keys (k_0, k_1) for each gate => secret output_table = {} # Garbled table for each gate => public garbled_table = {} # Ungarbling keys associated to my inputs => public input_keys = {} # OT senders for inputs of the other guy => public ot_senders = {} # ---- Input validation ---- for g_id, g_value in six.iteritems(myinputs): assert circuit.g[g_id].kind == "INPUT" assert g_value in (0, 1) # ---- Garbling keys generation ---- for g_id in circuit.g: # For output gates, we encrypt the binary output instead of an AES key. if not g_id in circuit.output_gates: k_0 = AES_key.gen_random() k_1 = AES_key.gen_random() output_table[g_id] = (k_0, k_1) # ---- Garbled tables generation ---- for g_id, gate in six.iteritems(circuit.g): # We already retrieved the values for all the input gates. if gate.kind != "INPUT": K_0 = output_table[gate.in0_id] # K_0 = k_00, k_01 K_1 = output_table[gate.in1_id] # K_1 = k_10, k_11 c_list = [] for i in range(2): for j in range(2): # 'real' evaluation of the gate on i,j alpha = Gate.compute_gate(gate.kind, i, j) if g_id in circuit.output_gates: m = _encode_int(alpha) # 0 or 1 else: K = output_table[g_id] m = _encode_key(K[alpha]) # k_0 or k_1 (see above) c = K_1[j].encrypt(m) c_ij = K_0[i].encrypt(c) c_list.append(c_ij) # @students: Why is it important to shuffle the list? # ANSWER: to avoid leaking keys due to the ordering of c_ij's (the # Garbled Circuit Table values) random.shuffle(c_list) garbled_table[g_id] = c_list # ---- Ungarbling keys generation for my inputs ---- for g_id, input_val in six.iteritems(myinputs): K = output_table[g_id] key = K[input_val] # key = K[i] where i in [0,1] is my input input_keys[g_id] = key # ---- Oblivious transfer senders ---- for g_id, gate in six.iteritems(circuit.g): if gate.kind == "INPUT" and g_id not in myinputs: k0, k1 = output_table[g_id] ot_senders[g_id] = OT.Sender(k0, k1) return (garbled_table, input_keys, ot_senders)
def main(target, tgt_port, src_ip, nsubflows, path, first_src_port, payloadFile, portShuffled, randomSrcPorts): conf = {"printanswer": False, "debug": 1, "check": False} t = ProtoTester(conf) s = MPTCPState() m = MPTCPTest(tester=t, initstate=s) timeout = .3 fileBufferSize = 1024 if not randomSrcPorts: ports = range(first_src_port, first_src_port + nsubflows) else: ports = [random.randrange(1, 65534) for i in range(nsubflows)] if portShuffled: shuffle(ports) t.toggleKernelHandling(src_ip, enable=False) try: #TODO:s abstract this into a function firstSubflow = True for port in ports: print "Opening connection from port", port if firstSubflow: conn_open = [m.CapSYN, m.Wait, m.CapACK] firstSubflow = False else: conn_open = [m.JoinSYN, m.Wait, m.JoinACK] sub = s.registerNewSubflow(dst=target, src=src_ip, dport=tgt_port, sport=port) t.sendSequence(conn_open, initstate=s, sub=sub, waitAck=True, timeout=timeout) print "Splitting payload across", len(ports), "subflows" if not payloadFile: payload = "GET {} HTTP/1.1 \r\nHost: {}\r\n\r\n".format( path, target) snt = m.send_data(s=s, data=path, waitAck=True, timeout=timeout) else: f = open(payloadFile) for data in read_file_chunks(f, fileBufferSize): snt = m.send_data(s=s, data=data, waitAck=True, timeout=timeout) #This acks data on every subflow 20 times #TODO: Abstract this into a function for i in range(1, 5): j = 0 for sflow in s.sub: #print "Subflow ", j, " cycling..." ackDss = [m.DSSACK] t.sendSequence(ackDss, initstate=s, sub=sflow, waitAck=True, timeout=timeout) j += 1 #print " ------- Heartbeat Number", str(i) j = 0 for sflow in s.sub: data_fin = [m.DSSFIN, m.DSSACK] t.sendSequence(data_fin, initstate=s, sub=sflow, waitAck=True, timeout=timeout) print "Subflow", j, "closed FIN" j += 1 except PktWaitTimeOutException: print("Waiting has timed out, test exiting with failure") sys.exit(1) except IOError: print("IO Error Occured - Does file exist?") finally: t.toggleKernelHandling( src_ip, enable=True) # or manually with iptables -X && iptables -F
def main(target, tgt_port, src_ip, nsubflows, path, first_src_port, payloadFile, portShuffled, randomSrcPorts): conf = {"printanswer":False, "debug":1, "check": False} t = ProtoTester(conf) s = MPTCPState() m = MPTCPTest(tester=t, initstate=s) timeout = .3 fileBufferSize = 1024 if not randomSrcPorts: ports = range(first_src_port, first_src_port + nsubflows) else: ports = [random.randrange(1,65534) for i in range(nsubflows)] if portShuffled: shuffle(ports) t.toggleKernelHandling(src_ip, enable=False) try: #TODO:s abstract this into a function firstSubflow = True for port in ports: print "Opening connection from port", port if firstSubflow: conn_open = [m.CapSYN, m.Wait, m.CapACK] firstSubflow=False else: conn_open = [m.JoinSYN, m.Wait, m.JoinACK] sub = s.registerNewSubflow(dst=target, src=src_ip, dport=tgt_port, sport=port) t.sendSequence(conn_open, initstate=s, sub=sub, waitAck=True,timeout=timeout) print "Splitting payload across", len(ports), "subflows" if not payloadFile: payload = "GET {} HTTP/1.1 \r\nHost: {}\r\n\r\n".format(path, target) snt = m.send_data(s=s, data=path, waitAck=True, timeout=timeout) else: f = open(payloadFile) for data in read_file_chunks(f, fileBufferSize): snt = m.send_data(s=s, data=data, waitAck=True, timeout=timeout) #This acks data on every subflow 20 times #TODO: Abstract this into a function for i in range(1, 5): j = 0 for sflow in s.sub: #print "Subflow ", j, " cycling..." ackDss=[m.DSSACK] t.sendSequence(ackDss, initstate=s, sub=sflow,waitAck=True, timeout=timeout) j += 1 #print " ------- Heartbeat Number", str(i) j = 0 for sflow in s.sub: data_fin = [m.DSSFIN, m.DSSACK] t.sendSequence(data_fin, initstate=s, sub=sflow, waitAck=True, timeout=timeout) print "Subflow", j, "closed FIN" j += 1 except PktWaitTimeOutException: print("Waiting has timed out, test exiting with failure") sys.exit(1) except IOError: print("IO Error Occured - Does file exist?") finally: t.toggleKernelHandling(src_ip, enable=True) # or manually with iptables -X && iptables -F
def complete_trade(self, trade_id, other_trade_id, other_pub_key): # First generate new pallier key-pair to maintain volume-secrecy # Now create bit representation of trade volume volume = self.waiting_trades[trade_id][ 'amt'] #Note: Max volume checked during trade send print("ORIG VOL: {}".format(volume)) lower_vol = 0 other_pub_key = construct(other_pub_key) perf_time = time.clock() # Buyer initiates (i.e. volume > 0) if volume > 0: pall_pub, pall_priv = paillier.generate_paillier_keypair() table = self.generate_table(volume, pall_pub) #print("DEBUG: volume_bits = {}\n table = {}".format(volume_bits, table)) msg = { 'method': 'send_table', 'params': [(other_pub_key.n, other_pub_key.e), (trade_id, other_trade_id), table] } # Wait to recieve dummy table print("DEBUG: Sending table") self.send_message(msg) # Send fake c vector print("DEBUG: Sending fake_c") fake_c = [ pall_pub.encrypt( random.randint(-pall_pub.n // 3, pall_pub.n // 3)) for i in range(VOLUME_NUM_BITS) ] msg = {'method': 'send_c', 'params': [fake_c]} # Recieve real result vector c = self.send_message(msg) # Decrypt c vector greater = False vals = [] for i in range(VOLUME_NUM_BITS): # In this case we don't care about overflow, only values that lead to 0 try: vals.append(pall_priv.decrypt_encoded(c[i]).decode()) except OverflowError as e: pass print("DEBUG: vals = {}".format(vals)) for val in vals: if val == 0: greater = True break print("DEBUG: Sending volume") if greater == True: # Buy > Sell (i.e. x > y) # Send 0 to indicate that y should send the lower value msg = { 'method': 'notify_volume', 'params': [other_pub_key.encrypt(0, None)[0]] } self.send_message(msg) print("Buy is greater") else: # Send the lower value to the other client msg = { 'method': 'notify_volume', 'params': [other_pub_key.encrypt(volume, None)[0]] } self.send_message(msg) lower_vol = volume print("Sell is greater") # Send fake volume notification msg = { 'method': 'send_min_volume', 'params': [other_pub_key.encrypt(lower_vol, None)[0]] } resp = self.send_message(msg) if lower_vol == 0: lower_vol = self.rsa_priv.decrypt(resp) print("CLIENT: (buyer) Completed trade {} with final volume = {}". format(self.waiting_trades[trade_id], lower_vol)) else: # Seller waits for buyer to send table, sends fake table to hide selling fake_pall_pub, fake_pall_priv = paillier.generate_paillier_keypair( ) fake_table = self.generate_table(random.randint(-1000000, 1000000), fake_pall_pub) msg = { 'method': 'send_table', 'params': [(other_pub_key.n, other_pub_key.e), (trade_id, other_trade_id), fake_table] } #Wait to recieve real table table = self.send_message(msg) pall_pub = table[0][0].public_key # Compute c vector y_volume_bits = auth_getvolumebits(abs(volume)) c = [] #[None]*VOLUME_NUM_BITS zero_enc = zero_encode(y_volume_bits) for t in zero_enc: n = len(y_volume_bits) - 1 x = None k = paillier.EncodedNumber.encode( pall_pub, random.randint(-pall_pub.n // 3, pall_pub.n // 3)) for i in range(len(t)): if x is None: x = table[t[0]][i] else: x += table[t[i]][i] c.append(x * k) while len(c) < len(y_volume_bits): c.append( pall_pub.encrypt( random.randint(-pall_pub.n // 3, pall_pub.n // 3))) #for i in range(VOLUME_NUM_BITS): # if y_volume_bits[i] == 0: # val = table[1][i] # k = random.randint(-pall_pub.n//3, pall_pub.n//3) # for j in range(i+1, VOLUME_NUM_BITS): # val += table[y_volume_bits[j]][j] # val *= k # c[i] = val # else: # c[i] = pall_pub.encrypt(random.randint(-pall_pub.n//3, pall_pub.n//3)) random.shuffle(c) msg = {'method': 'send_c', 'params': [c]} # Recieve fake c vector fake_c = self.send_message(msg) # Send fake volume notification to get response from other client msg = { 'method': 'notify_volume', 'params': [other_pub_key.encrypt(0, None)[0]] } buyer_notify = self.rsa_priv.decrypt(self.send_message(msg)) # Send minimum volume if we need to if buyer_notify == 0: msg = { 'method': 'send_min_volume', 'params': [other_pub_key.encrypt(abs(volume), None)[0]] } lower_vol = abs(volume) self.send_message(msg) print("(seller) Buy is Greater") else: msg = { 'method': 'send_min_volume', 'params': [other_pub_key.encrypt(0, None)[0]] } lower_vol = self.rsa_priv.decrypt(self.send_message(msg)) print("(seller) Sell is Greater") print("CLIENT: (seller) Completed trade {} with final volume = {}". format(self.waiting_trades[trade_id], lower_vol)) print("PERF: Volume Calc time: {}".format(time.clock() - perf_time)) if lower_vol != 0: msg = {'method': 'finish_trade', 'params': [trade_id]} self.send_message(msg) return raise RuntimeError("Trade Matched, but not completed")