def generate(word_list, words=5, specials=0): rnd = SystemRandom() words = [ rnd.choice(word_list) for _ in range(words) ] # Insert at most options.special special characters. This is not # exactly the procedure described in the Diceware web page, because # this handles the case where there are more than 6 words in the # passphrase and more than 6 characters in the word. if specials: split_words = [ map(None, x) for x in words ] for _ in range(specials): # i is the index of the word in which the special character # replacement takes place. i = rnd.randrange(len(split_words)) # j is the index of the character to be replaced with a special # character. j = rnd.randrange(len(split_words[i])) # k is the index of the special character k = rnd.randrange(len(SPECIAL_CHARS)) # Split to individual characters, replace the k'th char, unsplit split_words[i][j] = SPECIAL_CHARS[k] with_specials = [ "".join(x) for x in split_words ] else: with_specials = words return words, with_specials
def roll(count, sides): results = [] rand = SystemRandom() for x in range(count): if sides == 100 or sides == 1000: #Special Case for 100 sized dice results.append(rand.randint(1, 10)) results.append(rand.randrange(0, 100, 10)) if sides == 1000: results.append(rand.randrange(0, 1000, 100)) else: results.append(rand.randint(1, sides)) return results
def create_captcha(): rand = SystemRandom() left_number_index = rand.randrange(0, len(NUMBER_WORDS)) right_number_index = rand.randrange(0, len(NUMBER_WORDS)) operator_index = rand.randrange(0, len(OPERATORS)) answer = OPERATORS[operator_index][1](left_number_index, right_number_index) return ( 'Was ist {:s} {:s} {:s}?'.format( NUMBER_WORDS[left_number_index], OPERATORS[operator_index][0], NUMBER_WORDS[right_number_index] ), answer, )
def check_collisions(upper_bound): """ Function that keeps guessing random numbers 1 to N incluside, until it hits a collision (or doesn't) """ cryptogen = SystemRandom() # OS Internal system for generating cryptographic random numbers already_found = set([]) # Set of numbers the adversary already found iterations = 1 start = time.time() found = False try: while not found: # Runs until a collision is found item = cryptogen.randrange(1,upper_bound) # Uses the cryptographically secure PRNG to generate a random number if item in already_found: # If it's in the set of things already found - print the statistics found = True print "duplicate found in %.2e tries in %f seconds" % (iterations, time.time()-start) print "The upper bound on this probability is %.2f %%" % (coll(iterations,upper_bound)*100) else: # If it's a new number, add it to the set of numbers checked already_found.add(item) iterations+=1 except KeyboardInterrupt: # If someone cancels the program midway - prints some statistics about the current progress total_time = time.time()-start print "Program cancelled - made %.2e attempts in %.4f seconds" % (iterations, total_time) print "The upper bound on getting a duplicate is %.2f %%" % (coll(iterations,upper_bound)*100) onepercent = ntimes(.01,upper_bound) rate = total_time/iterations seconds = onepercent*rate print "To have 1%% probability of guessing you need at least %d tries, at this rate it would take %f seconds" % (onepercent, seconds) print "%.2f minutes, %.2f hours, %.2f days, %.2f years" % (seconds/60, seconds/60/60, seconds/60/60/24, seconds/60/60/24/365)
def generate_salt(): # This uses os.urandom() underneath cryptogen = SystemRandom() # Create 16 byte hex salt salt_sequence = [cryptogen.randrange(256) for _ in range(16)] return ''.join([format(r, 'x') for r in salt_sequence])
def newAccount(): """ Create's a new account under this user. Balance is always 0 """ try: check_params(request, ["session", "pin"]) user = validate_session(request.form["session"]) except StandardError as e: return respond(str(e), code=400), 400 gen = SystemRandom() accnum = str(''.join(map(str, [gen.randrange(9) for i in range(10)]))) pin = int(request.form["pin"]) newaccount = Account(accnum, user, 0.00, pin) try: db.session.add(newaccount) db.session.commit() add_log(LOG_ACCOUNT, "User %s created a new account (%s)" % (user.username, accnum)) except: db.session.rollback() return respond("An internal error has occured. Please try again.", code=400), 400 # Delete their session delete_session(request.form["session"]) return respond("Account created!", data={'account': newaccount.id, 'pin': newaccount.pin})
def client_func(E, P, Q): n = E.order gen = SystemRandom() an = gen.randrange(n) bn = gen.randrange(n) am = an bm = bn Xn = P*an + Q*bn Xm = Xn while (True): i = __H(Xn, L) Xn += R[i] an += c[i] bn += d[i] for j in range(2): h = __H(Xm, L) Xm += R[h] am += c[h] bm += d[h] if Xn == Xm: break if (bn == bm): raise ArithmeticError('Undefined value') f = an-am g = invmod(bm-bn, n) ret = (f * g) % n ret = (ret + n) % n sendToServer(ret)
def createRandomToken(self): '''Create a random byte sequence to use as a repeating token''' r = SystemRandom() token = bytearray() numBytes = r.choice([3, 4, 5, 6]) for i in range(numBytes): token.append(r.randrange(256)) return token
def get_prime(low, high): csprng = SystemRandom() n = csprng.randrange(low, high) if n % 2 == 0: n += 1 while not miller_rabin(n): n += 2 return n
def serial(E, P, Q): print 'Algorithm: serial' c = []; d = []; R = [] n = E.order L = 4 gen = SystemRandom() for i in range(L): c.append(gen.randrange(n-1)+1) d.append(gen.randrange(n-1)+1) R.append(P*c[-1] + Q*d[-1]) an = gen.randrange(n) bn = gen.randrange(n) am = an bm = bn Xn = P*an + Q*bn Xm = Xn while (True): i = __H(Xn, L) Xn += R[i] an += c[i] bn += d[i] for j in range(2): h = __H(Xm, L) Xm += R[h] am += c[h] bm += d[h] if Xn == Xm: break if (bn == bm): raise ArithmeticError("Undefined value") f = an-am g = invmod(bm-bn, n) ret = (f * g) % n return (ret + n) % n
def random_prime(): random = SystemRandom() prime_generator = iter(primes()) prime_number = next(prime_generator) for _ in range(random.randrange(42)): prime_number = next(prime_generator) while not is_marsenne_prime(prime_number): prime_number = next(prime_generator) return marsenne_number(prime_number)
def _gen_key(): from random import SystemRandom r = SystemRandom() l = r.randrange(len(KEY_DIGITS)**KEY_LENGTH) key = '' while l >= KEY_BASE: remainder = l % KEY_BASE key += KEY_DIGITS[remainder] l = l / KEY_BASE key += KEY_DIGITS[l] key = key[::-1] return key
def main(): if os.access("/usr/share/dict/words", os.R_OK): # Debian file = "/usr/share/dict/words" elif os.access("/usr/share/dict/linux.words", os.R_OK): # CentOS file = "/usr/share/dict/linux.words" elif os.access("words.txt", os.R_OK): # cwd, Windows, user-placed file file = "words.txt" else: sys.exit("Could not locate the system dictionary file - please manually edit the file location.") if benchmark: start = time.time() file = open(file, "r") wordlist = file.readlines() file.close() cryptogen = SystemRandom() wordindexes = [cryptogen.randrange(len(wordlist)) for i in range(numwords)] words = [wordlist[index] for index in wordindexes] if numerifywords: # enact before capitalization words = [word.replace("o", "0") for word in words] # 'o' to zero: just one way of mangling letters # words = [word.replace('a', '@') for word in words] # words = [word.replace('s', '5') for word in words] words = [word.capitalize() for word in words] words = [word.rstrip() for word in words] # remove line breaks words = [word.replace("'s", "") for word in words] # remove apostrophe s rndnumber = cryptogen.randrange(numberlimit) print("".join(words) + str(rndnumber)) if benchmark: print("\ntime taken " + str(time.time() - start) + " sec")
class RandomGenerator: def __init__(self): self.gen = SystemRandom() def get_random_vector(self, length): random_vector = np.array([self.gen.randrange(2) for i in range(length)]) return random_vector def get_random_weight_vector(self, length, weight): random_indices = set([self.gen.randrange(length) for i in range(weight)]) while len(random_indices) < weight: random_indices.update([self.gen.randrange(length)]) random_vector = np.zeros(length, dtype='int') random_vector[list(random_indices)] = 1 return random_vector def flip_coin(self): return self.gen.randrange(2)
def rand(end, start=None, step=None): r = SystemRandom() if isinstance(end, (int, long)): if not start: start = 0 if not step: step = 1 return r.randrange(start, end, step) elif hasattr(end, '__iter__'): if start or step: raise errors.AnsibleFilterError('start and step can only be used with integer values') return r.choice(end) else: raise errors.AnsibleFilterError('random can only be used on sequences and integers')
def privatekeygenerator(): """ Generate new private key """ subgroups_length = [8, 4, 4, 4, 12] subgroup_separator = '-' allowed_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" systemrandom = SystemRandom() allowedcharslength = len(allowed_chars) key = "" for i in range(0, len(subgroups_length)): for j in range(0, subgroups_length[i]): key += allowed_chars[systemrandom.randrange(allowedcharslength)] if i < (len(subgroups_length) -1): key += subgroup_separator return key
def find_meaning_from_history(): '''displays a random meaning from searched history. searched history is saved in a file `meanings.json` under home directory''' searched_meaning = OrderedDict() random_instance = SystemRandom() if os.path.isfile(FILE_PATH): with open(FILE_PATH, 'r') as f: all_meanings_searched = json.load(f) r_int = random_instance.randrange(len(all_meanings_searched)) # to not break the existing meanings file, need to create a OrderedDict here # so that word comes before meaning key searched_meaning['word'] = all_meanings_searched[r_int]['word'] searched_meaning['meaning'] = all_meanings_searched[r_int]['meaning'] return searched_meaning
def rand(environment, end, start=None, step=None, seed=None): if seed is None: r = SystemRandom() else: r = Random(seed) if isinstance(end, integer_types): if not start: start = 0 if not step: step = 1 return r.randrange(start, end + 1, step) elif hasattr(end, '__iter__'): if start or step: raise AnsibleFilterError('start and step can only be used with integer values') return r.choice(end) else: raise AnsibleFilterError('random can only be used on sequences and integers')
class Diceware: """A Class that creates an object for creating cryptographically safe random numbers.""" def __init__(self): # Use the OS specific function to generate random numbers for greater security self.cryptogen = SystemRandom() self.cryptolist = list() def dice_roll(self, start=1, end=6, num_range=5): """Creates a list of numbers with a given range. Keyword arguments: start -- the start of the number range (default is 1) end -- the end of the number range (default is 6) num_range -- the length of the list of numbers to generate (default is 5) """ # The randrange function takes a starting number and goes up to, but does not include the end number # so let's add 1 to the end number to include it. self.cryptolist = [self.cryptogen.randrange(start, (end + 1)) for i in range(num_range)] def word_lookup(self): """Creates a string from the cryptographically safe list of numbers, which is used to search the diceware word list file. """ # Make sure we start with an empty string self.num_to_string = "" # Iterate through the list, adding each number to the string for i in self.cryptolist: self.num_to_string += str(i) # We'll try and open the diceware word list file, search it, then return the word try: with open("diceware.wordlist", "r") as handler: for line in handler: if self.num_to_string in line: # Return only the word, removing the numbers and whitespace return line[len(self.num_to_string):].strip() except FileNotFoundError: # Whoops, the diceware word list cannot be found print("Unable to open " + str(os.getcwd()) + "\diceware.wordlist - File not found.")
def draw(request, lottery_id): lottery = get_object_or_404(Lottery, pk=lottery_id) if lottery.multiple_winnings: participants = lottery.lotteryparticipant_set.all() else: participants = lottery.lotteryparticipant_set.all().exclude(has_won=True) # print lottery.lotterywinner_set.all() if len(participants) < 1: messages.error(request, 'No eligible participants') return redirect(drawing, lottery_id) rand = SystemRandom() winner_id = rand.randrange(0, len(participants)) winner = participants[winner_id].user participants[winner_id].has_won = True participants[winner_id].save() LotteryWinner.objects.create(user=winner, lottery=lottery) return redirect(drawing, lottery_id)
def makecode(request,cursor,acc_id): coupon_id = request['id'] target_id = request['target'] cursor.execute("SELECT points,name FROM offers WHERE offer_id = %s",(coupon_id,)) coupon_points = cursor.fetchone() if (coupon_points is None): return (404,{}) offer_name = coupon_points[1] coupon_points = coupon_points[0] rng = SystemRandom() code = rng.randrange(100000,999999) cursor.execute("INSERT INTO coupons VALUES (%s,%s,%s,%s)",(target_id,code,acc_id,coupon_id)) cursor.execute("SELECT stores,counts FROM points WHERE acc_id = %s",(target_id,)) store_info = cursor.fetchone() target_stores = store_info[0] target_counts = store_info[1] cursor.execute("SELECT fullname, msgval FROM endusers WHERE acc_id = %s",(target_id,)) target_info = cursor.fetchone() target_name = target_info[0] msgval = target_info[1] target_counts[target_stores.index(acc_id)] = target_counts[target_stores.index(acc_id)] - coupon_points cursor.execute("UPDATE points SET counts = %s WHERE acc_id = %s",(target_counts,target_id)) ret = {} ret['points'] = target_counts[target_stores.index(acc_id)] ret['name'] = target_name cursor.execute("SELECT template FROM stores WHERE acc_id = %s",(acc_id,)) msg_info = cursor.fetchone() template = msg_info[1] subject = "Here is your coupon." a_or_an = "a" if (offer_name[0] in 'aeiou'): a_or_an = "an" header = "Here's your coupon code for " + a_or_an + " " + offer_name + "." message = "Your code is " + str(code) + ". Use it next time you visit!" sendMsg(cursor,target_id,acc_id,subject,header,message,template) return (200,ret)
def parallelized(E, P, Q): print 'Algorithm: parallelized' n = E.order gen = SystemRandom() for i in range(L): c.append(gen.randrange(n)) d.append(gen.randrange(n)) R.append(P*c[-1] + Q*d[-1]) # create manager with the return value manager = Manager() return_dict = manager.dict() # create the server server = Process(name='server', target=server_func, args=(n, return_dict)) cores = mp.cpu_count() workers = [] # create the processes for i in range(cores): w = Process(name='worker_'+str(i+1), target=client_func, args=(E, P, Q)) workers.append(w) w.start() server.start() server.join() # wait server end # kill the processes for w in workers: w.terminate() # empty lists del c[:], d[:], R[:], workers[:] x = return_dict[0] return x
from random import randrange from string import punctuation, ascii_letters, digits #Section 55.1: Creating a random user password print("------Section 55.1: Creating a random user password---------") symbols = ascii_letters + digits + punctuation secure_random = random.SystemRandom() password = "".join(secure_random.choice(symbols) for i in range(10)) print(password) #Section 55.2: Create cryptographically secure random numbers print("-----------Section 55.2: Create cryptographically secure random numbers------") secure_rand_gen = SystemRandom() print([secure_rand_gen.randrange(10) for i in range(10)]) print(secure_rand_gen.randint(0, 20)) #Section 55.3: Random and sequences: shuffle, choice and sample print("-------Section 55.3: Random and sequences: shuffle, choice and sample-----------") #shuffle laughs = ["Hi", "Ho", "He"] random.shuffle(laughs) # Shuffles in-place! Don't do: laughs = random.shuffle(laughs) print(laughs) #choice() print(random.choice(laughs)) #sample()
#Crypto Random import os #os module is needed for urandom os.urandom(10) #returns 10 random bytes suitable for cryptography type(os.urandom(10)) #returns the type map(ord, os.urandom(10)) #System Random from random import SystemRandom cryptogen = SystemRandom() [cryptogen.randrange(3) for i in range(20)] #random ints in range 3 [cryptogen.random() for i in range(3)] #randomfloats in [0., 1.]
elapsed_time = time.time() - start_time if line in i: print "I got it !" return True if elapsed_time > 60 * randcon: return False counting = 0 def count(success): if success: global counting counting = counting + 1 cryptogen = SystemRandom() num = cryptogen.randrange(len(contlist)) broadcaster = contlist[num] tools.broadcast(advclient, broadcaster["cont"], "gossip_test", "Hello!") contlist.remove(broadcaster) runMultiple(waitForGossipMessage, count) print str(counting) + " nodes got the gossip message" print "Starting to shutdown nodes" contlist.append({ "cont": bootstrap }) contlist.append({ "cont": broadcaster["cont"] }) tools.cleanUp(contlist)
class FlaskSessionCaptcha(object): def __init__(self, app=None): if app is not None: self.init_app(app) def init_app(self, app): """ Initialize the captcha extension to the given app object. """ self.enabled = app.config.get("CAPTCHA_ENABLE", True) self.digits = app.config.get("CAPTCHA_LENGTH", 4) self.width = app.config.get("CAPTCHA_WIDTH") self.height = app.config.get("CAPTCHA_HEIGHT") self.session_key = app.config.get("CAPTCHA_SESSION_KEY", "captcha_answer") self.max = 10**self.digits xargs = {} if self.height: xargs['height'] = self.height if self.width: xargs['width'] = self.width self.image_generator = ImageCaptcha(**xargs) self.rand = SystemRandom() def _generate(css_class=None): if not self.enabled: return "" base64_captcha = self.generate() data = "data:image/png;base64, {}".format(base64_captcha) if css_class is not None: return Markup("<img src='{}' class='{}'>".format( data, css_class)) return Markup("<img src='{}'>".format(data)) app.jinja_env.globals['captcha'] = _generate # Check for sessions that do not persist on the server. Issue a warning because # they are most likely open to replay attacks. This addon is built upon flask-session. session_type = app.config.get('SESSION_TYPE') if session_type is None or session_type == "null": raise RuntimeWarning( "Flask-Sessionstore is not set to use a server persistent storage type. This likely means that captchas are vulnerable to replay attacks." ) elif session_type == "sqlalchemy": # I have to do this as of version 0.3.1 of flask-session if using sqlalchemy as the session type in order to create the initial database. # Flask-sessionstore seems to have the same problem. app.session_interface.db.create_all() def generate(self): """ Generates and returns a numeric captcha image in base64 format. Saves the correct answer in `session[self.session_key]` Use later as: src = captcha.generate() <img src="{{src}}"> """ answer = self.rand.randrange(self.max) answer = str(answer).zfill(self.digits) image_data = self.image_generator.generate(answer) base64_captcha = base64.b64encode( image_data.getvalue()).decode("ascii") logging.debug('Generated captcha with answer: ' + answer) session[self.session_key] = answer return base64_captcha def validate(self, form_key="captcha", value=None): """ Validate a captcha answer (taken from request.form) against the answer saved in the session. Returns always true if CAPTCHA_ENABLE is set to False. Otherwise return true only if it is the correct answer. """ if not self.enabled: return True session_value = session.get(self.session_key) if not session_value: return False if not value and form_key in request.form: value = request.form[form_key].strip() # invalidate the answer to stop new tries on the same challenge. session[self.session_key] = None return value is not None and value == session_value def get_answer(self): """ Shortcut function that returns the currently saved answer. """ return session.get(self.session_key)
class BiasedRandomSequence: """ A list-like type that facilitates random sampling based on an items probability of being chosen. The probability that an item will be chosen is converted into a range that starts at the ends of the range of the item that came before it. Given an item with, value = 12 and prob = 22 If there are no other objects in the sequence then the range, reffered to as the probability index, that can be depicted as follows: [(0, 1, 2, 3,... 21):12] Appending an item with, value = 7 and prob = 8, results in the following sequence: [(0, 1, 2, 3,... 21):12, (22, 23, 24,..., 30):8] >>> my_list = BiasedRandomSequence() >>> prob, value = 50, 3 >>> my_list.append(prob, value) >>> my_list[0] 3 >>> my_list.append(50, 6) >>> my_list [3, 6] >>> len(my_list) 2 >>> my_list.random_get() in [3, 6] True """ def __init__(self, *new_items, insert_key=None): """ Input: a sequence of items, and a function that determines their probablities of being chosen """ self._data_dict = dict() self._index_to_range_dict = dict() self._max_prob_index = 0 self._randomizer = SystemRandom() if insert_key is not None: for item in new_items: self.append(insert_key(item), item) @property def max_index(self): """ Input: None Output: the index of the most recently appended item """ return len(self) - 1 def __len__(self): return len(self._data_dict) def __repr__(self): """ Input: None OUtput: the python representation of the sequence >>> my_list = BiasedRandomSequence() >>> my_list.append(10, 1) >>> my_list.append(20, 2) >>> my_list.append(30, 3) >>> my_list.append(30, 4) >>> my_list [1, 2, 3, 4] """ return str([self[i] for i in range(len(self))]) def __getitem__(self, index): """ Input: a list index Output: the item at that index, if one exists >>> my_list = BiasedRandomSequence() >>> my_list.append(10, 1) >>> my_list.append(20, 2) >>> my_list.append(30, 3) >>> my_list.append(30, 4) >>> my_list[0] 1 >>> my_list[1] 2 >>> my_list[4] Traceback (most recent call last): ... IndexError: index out of bounds """ if index >= len(self): raise IndexError("index out of bounds") return self._data_dict[self._index_to_range_dict[index]] def __iter__(self): """ Input: None Output: an iterator that walks down the sequence, returning items in the order they were added """ return BRSequenceIterator(self) def _prob_to_range(self, prob): """ Input: a probability between 0 and 100 Output: a range starting at the _max_prob_index and ending at prob + self._max_prob_index """ return range(self._max_prob_index, prob + self._max_prob_index) def append(self, prob, value): """ Input: a probability between 0 and 100, and a value that has probablity prob of being chosen from the sequence Output: None """ if prob > 0: self._data_dict[self._prob_to_range(prob)] = value self._index_to_range_dict[self.max_index] = self._prob_to_range(prob) self._max_prob_index += prob def random_get(self): """ Input: None Output: returns a value, based on that values probability of being chosen """ prob_index = self._randomizer.randrange(self._max_prob_index) for key in self._data_dict.keys(): if prob_index in key: return self._data_dict[key]
selected_pois = {} #No duplicates selected_aas = {"A":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0,"I":0,"K":0,"L":0,"M":0,"N":0,"P":0,"Q":0,"R":0,"S":0,"T":0,"V":0,"W":0,"Y":0} output_file = ChangeToFolder( output_file, curdir) print "Writing output to file: '%s'" % output_file #sys.exit( 0) pb.InitProgressBar( n_pois_written, selections_to_make, 1.0) with open( output_file, "w") as of: while n_pois_written < selections_to_make: #for header, seq in seqs: rand_index = cryptogen.randrange( n_available_selections) seq_key = seq_record_indices[ rand_index] cur_seq = str( seq_record_index[ seq_key].seq).replace( "*", "") if len( cur_seq) < 25: continue #Skip short sequences seq_len = len( cur_seq) header = seq_record_index[ seq_key].description poi_positions = [] if seq_key in selected_pois: poi_positions = selected_pois[ seq_key] tries = 0 while True: if tries >= 1500: pb.PrintAboveProgressBar( "No suitable poi found for seq: %s" % header ) n_notfound += 1
def crypto_choice(rng: random.SystemRandom, choices: Sequence): return choices[rng.randrange(0, len(choices))]
parser.add_argument("count", metavar="N", type=int, help="number of sets") parser.add_argument("length", metavar="K", type=int, help="number of unit intervals") parser.add_argument("range", metavar="R", type=int, help="range unit intervals") args = parser.parse_args() cryptogen = SystemRandom() count = 0 total = 0.0 interval_count = 0 for run in range(args.runs): sets = [] for index in range(args.count): current = [] for cursor in range(args.length): rand = cryptogen.randrange(args.range) current.append((rand, rand + 1)) sets.append(FrozenIntervalSet[int](current)) # type: ignore interval_count += len(sets[-1]) start = time.time() count += len( FrozenIntervalSet[int]([Interval[int]()]).intersection(*sets) # type: ignore ) end = time.time() total += end - start print( f"{count / args.runs}," f"{interval_count / args.runs / args.count}," f"{total / args.runs}" )
class SecureRandomSource(object): def __init__(self): self.rand = SystemRandom() def randrange(self, start, end): return self.rand.randrange(start, end)
delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL, lineterminator='\n') cryptogen = SystemRandom() #wtr.writerow(['tweet_id', 'author_id', 'number_of_urls', 'expanded_url']) count = 0 u_count = 0 m_count = 0 nu_count = 0 while True: count += 1 t = t_ids[cryptogen.randrange(len(t_ids) - 1)] t_ids.remove(t) try: tweet = api.get_status(t[0]) if len(tweet._json['entities']['urls']) > 0: urls = [u['expanded_url'] for u in tweet._json['entities']['urls']] wtr.writerow(t + ['%s' % len(urls)] + urls) nf.flush() u_count += 1 else: nu_count += 1 wtr.writerow(t + ['0', 'n']) nf.flush() except tweepy.error.TweepError, e: try:
class DEPQTest(unittest.TestCase): def setUp(self): self.depq = DEPQ() self.random = SystemRandom() def tearDown(self): self.depq.clear() def test_init_default(self): self.assertEqual(len(self.depq.data), 0) self.assertEqual(self.depq._maxlen, None) def test_init_set_iterable(self): depq_non_default = DEPQ([['last', 1], ['first', 3]]) self.assertEqual(len(depq_non_default), 2) self.assertEqual(is_ordered(depq_non_default), True) def test_maxlen(self): self.assertEqual(self.depq.maxlen, None) def test_set_maxlen(self): self.depq.extend((None, i) for i in range(7)) self.depq.set_maxlen(5) self.assertEqual(self.depq.low(), 2) def test_count_unset_with_hashable(self): self.assertEqual(self.depq.count('test'), 0) def test_count_unset_with_unhashable(self): self.assertEqual(self.depq.count(['test']), 0) def test_in_operator_unset_hashable(self): self.assertEqual('test' in self.depq, False) def test_in_operator_unset_unhashable(self): self.assertEqual(['test'] in self.depq, False) def test_insert_initial_membership_new_hashable_with_in_operator(self): self.depq.insert('test', 7) self.assertEqual('test' in self.depq, True) def test_insert_initial_membership_new_unhashable_with_in_operator(self): self.depq.insert(['test'], 7) self.assertEqual(['test'] in self.depq, True) def test_insert_mass_membership_new_hashable_with_in_operator(self): self.depq.insert('test1', 7) self.depq.insert('test2', 5) self.assertEqual('test2' in self.depq, True) def test_insert_mass_membership_new_unhashable_with_in_operator(self): self.depq.insert('test1', 7) self.depq.insert(['test2'], 5) self.assertEqual(['test2'] in self.depq, True) def test_insert_mass_membership_add_hashable_with_count(self): self.depq.insert('test', 7) self.depq.insert('test', 5) self.assertEqual(self.depq.count('test'), 2) def test_insert_mass_membership_add_unhashable_with_count(self): self.depq.insert(['test'], 7) self.depq.insert(['test'], 5) self.assertEqual(self.depq.count(['test']), 2) def test_insert_initial_populate_first(self): self.depq.insert(None, 4) self.depq.insert(None, 6) self.assertEqual(is_ordered(self.depq), True) self.depq.insert(None, 5) self.assertEqual(is_ordered(self.depq), True) def test_insert_initial_populate_last(self): self.depq.insert(None, 6) self.depq.insert(None, 4) self.assertEqual(is_ordered(self.depq), True) self.depq.insert(None, 5) self.assertEqual(is_ordered(self.depq), True) def test_insert_mass_populate_order(self): for i in range(self.random.randrange(20, 100)): self.depq.insert(None, self.random.randrange(-1000, 1000)) self.assertEqual(is_ordered(self.depq), True) def test_insert_exceed_maxlen(self): depq_non_default = DEPQ(((None, i) for i in range(5)), 4) self.assertEqual(depq_non_default.low(), 1) def test__repr__empty(self): self.assertEqual(repr(self.depq), "DEPQ([])") def test__repr__one_item(self): self.depq.insert(None, 5) self.assertEqual(repr(self.depq), "DEPQ([(None, 5)])") def test__repr__multiple_items(self): self.depq.insert(None, 5) self.depq.insert('test', 3) self.assertEqual(repr(self.depq), "DEPQ([(None, 5), ('test', 3)])") def test__str__and__unicode__empty(self): self.assertEqual(str(self.depq), "DEPQ([])") self.assertEqual(str(self.depq), self.depq.__unicode__()) def test__str__and__unicode__one_item(self): self.depq.insert(None, 5) self.assertEqual(str(self.depq), "DEPQ([(None, 5)])") self.assertEqual(str(self.depq), self.depq.__unicode__()) def test__str__and__unicode__multiple_items(self): self.depq.insert(None, 5) self.depq.insert('test', 3) self.assertEqual(str(self.depq), "DEPQ([(None, 5), ('test', 3)])") self.assertEqual(str(self.depq), self.depq.__unicode__()) def test__setitem__calls_insert(self): self.depq[None] = 5 self.assertEqual(None in self.depq, True) def test__delitem__raise_error(self): self.depq.insert(None, 5) with self.assertRaises(NotImplementedError): del self.depq[0] def test__getitem__empty_raise_error(self): with self.assertRaises(IndexError): self.depq[0] += 1 def test__getitem__with_items(self): self.depq.insert('last', 1) self.depq.insert('first', 7) self.depq.insert('middle', 5) self.assertEqual(self.depq[0], ('first', 7)) self.assertEqual(self.depq[1], ('middle', 5)) self.assertEqual(self.depq[2], ('last', 1)) self.assertEqual(self.depq[-1], ('last', 1)) def test_first_and_last_empty_raise_error(self): with self.assertRaises(IndexError): self.depq.first() with self.assertRaises(IndexError): self.depq.last() def test_first_and_last_one_item(self): self.depq.insert(None, 1) self.assertEqual(self.depq.first(), None) self.assertEqual(self.depq.first(), self.depq.last()) def test_first_and_last_multiple_items(self): self.depq.insert('last', 1) self.depq.insert('first', 5) self.assertEqual(self.depq.first(), 'first') self.assertEqual(self.depq.last(), 'last') def test_high_and_low_empty_raise_error(self): with self.assertRaises(IndexError): self.depq.high() with self.assertRaises(IndexError): self.depq.low() def test_high_and_low_one_item(self): self.depq.insert(None, 1) self.assertEqual(self.depq.high(), 1) self.assertEqual(self.depq.high(), self.depq.low()) def test_high_and_low_multiple_items(self): self.depq.insert(None, 1) self.depq.insert(None, 5) self.assertEqual(self.depq.high(), 5) self.assertEqual(self.depq.low(), 1) def test_size_and_len(self): self.assertEqual(len(self.depq), 0) self.assertEqual(len(self.depq), self.depq.size()) self.depq.insert(None, 5) self.assertEqual(len(self.depq), 1) self.assertEqual(len(self.depq), self.depq.size()) def test_is_empty(self): self.assertEqual(self.depq.is_empty(), True) self.depq.insert(None, 5) self.assertEqual(self.depq.is_empty(), False) def test_clear(self): self.depq.insert('last', 1) self.assertEqual(self.depq.size(), 1) self.assertEqual(len(self.depq.items), 1) self.depq.clear() self.assertEqual(self.depq.size(), 0) self.assertEqual(len(self.depq.items), 0) def test_addfirst_populate_default(self): for i in range(self.random.randrange(20, 100)): self.depq.addfirst(None) self.assertEqual(is_ordered(self.depq), True) self.assertEqual(self.depq.high(), self.depq.low()) def test_addfirst_populate_with_arg(self): for i in range(self.random.randrange(20, 100)): self.depq.addfirst(None, i) self.assertEqual(is_ordered(self.depq), True) self.assertGreater(self.depq.high(), self.depq.low()) def test_addfirst_initial_priority(self): self.depq.addfirst(None) self.assertEqual(self.depq.high(), 0) def test_addfirst_initial_priority_with_arg(self): self.depq.addfirst(None, 10) self.assertEqual(self.depq.high(), 10) def test_addfirst_smaller_priority_raise_error(self): self.depq.addfirst(None, 7) with self.assertRaises(ValueError): self.depq.addfirst(None, 6) def test_addfirst_membership_new_hashable(self): self.depq.addfirst('test') self.assertEqual(self.depq.count('test'), 1) def test_addfirst_membership_new_unhashable(self): self.depq.addfirst(['test']) self.assertEqual(self.depq.count(['test']), 1) def test_addfirst_membership_add_hashable(self): self.depq.addfirst('test') self.depq.addfirst('test') self.assertEqual(self.depq.count('test'), 2) def test_addfirst_membership_add_unhashable(self): self.depq.addfirst(['test']) self.depq.addfirst(['test']) self.assertEqual(self.depq.count(['test']), 2) def test_addfirst_exceed_maxlen(self): depq_non_default = DEPQ(((None, i) for i in range(5)), 5) depq_non_default.addfirst(None, 10) self.assertEqual(depq_non_default.low(), 1) def test_addlast_populate_default(self): for i in range(self.random.randrange(20, 100)): self.depq.addlast(None) self.assertEqual(is_ordered(self.depq), True) self.assertEqual(self.depq.high(), self.depq.low()) def test_addlast_populate_with_arg(self): for i in reversed(range(self.random.randrange(20, 100))): self.depq.addlast(None, i) self.assertEqual(is_ordered(self.depq), True) self.assertGreater(self.depq.high(), self.depq.low()) def test_addlast_initial_priority(self): self.depq.addlast(None) self.assertEqual(self.depq.high(), 0) def test_addlast_initial_priority_with_arg(self): self.depq.addlast(None, 10) self.assertEqual(self.depq.high(), 10) def test_addlast_larger_priority_raise_error(self): self.depq.addlast(None, 7) with self.assertRaises(ValueError): self.depq.addlast(None, 8) def test_addlast_membership_new_hashable(self): self.depq.addlast('test') self.assertEqual(self.depq.count('test'), 1) def test_addlast_membership_new_unhashable(self): self.depq.addlast(['test']) self.assertEqual(self.depq.count(['test']), 1) def test_addlast_membership_add_hashable(self): self.depq.addlast('test') self.depq.addfirst('test') self.assertEqual(self.depq.count('test'), 2) def test_addlast_membership_add_unhashable(self): self.depq.addlast(['test']) self.depq.addfirst(['test']) self.assertEqual(self.depq.count(['test']), 2) def test_addlast_exceed_maxlen(self): depq_non_default = DEPQ(((None, i) for i in range(5)), 5) depq_non_default.addlast(None, -1) self.assertEqual(depq_non_default.low(), 0) def test_popfirst_empty_raise_error(self): with self.assertRaises(IndexError): self.depq.popfirst() def test_popfirst_membership_remove_hashable(self): self.depq.insert('test', 5) self.depq.popfirst() self.assertEqual(self.depq.count('test'), 0) def test_popfirst_membership_remove_unhashable(self): self.depq.insert(['test'], 5) self.depq.popfirst() self.assertEqual(self.depq.count(['test']), 0) def test_popfirst_membership_decrement_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.popfirst() self.assertEqual(self.depq.count('test'), 1) def test_popfirst_membership_decrement_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.popfirst() self.assertEqual(self.depq.count(['test']), 1) def test_popfirst_order(self): for i in range(5): self.depq.insert('test', i) self.depq.popfirst() self.assertEqual(self.depq.high(), 3) def test_poplast_empty_raise_error(self): with self.assertRaises(IndexError): self.depq.poplast() def test_poplast_membership_remove_hashable(self): self.depq.insert('test', 5) self.depq.poplast() self.assertEqual(self.depq.count('test'), 0) def test_poplast_membership_remove_unhashable(self): self.depq.insert(['test'], 5) self.depq.poplast() self.assertEqual(self.depq.count(['test']), 0) def test_poplast_membership_decrement_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.poplast() self.assertEqual(self.depq.count('test'), 1) def test_poplast_membership_decrement_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.poplast() self.assertEqual(self.depq.count(['test']), 1) def test_poplast_order(self): for i in range(5): self.depq.insert('test', i) self.depq.poplast() self.assertEqual(self.depq.low(), 1) def test_remove_invalid_count_raise_error(self): with self.assertRaises(ValueError): self.depq.remove('test', 'test') with self.assertRaises(TypeError): self.depq.remove('test', []) def test_remove_unset_hashable(self): self.assertEqual(self.depq.remove('test'), []) def test_remove_unset_unhashable(self): self.assertEqual(self.depq.remove(['test']), []) def test_remove_zero_does_nothing(self): self.depq.insert('test', 5) self.assertEqual(self.depq.remove('test', 0), []) self.assertEqual(self.depq.count('test'), 1) def test_remove_default_membership_remove_hashable(self): self.depq.insert('test', 5) self.depq.remove('test') self.assertEqual(self.depq.count('test'), 0) def test_remove_default_membership_remove_unhashable(self): self.depq.insert(['test'], 5) self.depq.remove(['test']) self.assertEqual(self.depq.count(['test']), 0) def test_remove_default_membership_decrement_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.remove('test') self.assertEqual(self.depq.count('test'), 1) def test_remove_default_membership_decrement_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.remove(['test']) self.assertEqual(self.depq.count(['test']), 1) def test_remove_inbound_arg_membership_remove_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.remove('test', 2) self.assertEqual(self.depq.count('test'), 0) def test_remove_inbound_arg_membership_remove_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.remove(['test'], 2) self.assertEqual(self.depq.count(['test']), 0) def test_remove_outbound_arg_membership_remove_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.remove('test', 100) self.assertEqual(self.depq.count('test'), 0) def test_remove_outbound_arg_membership_remove_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.remove(['test'], 100) self.assertEqual(self.depq.count(['test']), 0) def test_remove_inbound_arg_membership_decrement_hashable(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.insert('test', 3) self.depq.remove('test', 2) self.assertEqual(self.depq.count('test'), 1) def test_remove_inbound_arg_membership_decrement_unhashable(self): self.depq.insert(['test'], 5) self.depq.insert(['test'], 7) self.depq.insert(['test'], 3) self.depq.remove(['test'], 2) self.assertEqual(self.depq.count(['test']), 1) def test_remove_membership_with_elim(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.elim('test') self.assertEqual(self.depq.count('test'), 0) def test_remove_order(self): self.depq.insert('test', 5) self.depq.insert('test', 7) self.depq.insert('test', 3) self.depq.insert('test', 1) self.depq.remove('test', 2) self.assertEqual(self.depq.low(), 5) self.assertEqual(is_ordered(self.depq), True) def test_pickle(self): for i in range(5): self.depq.insert([i], i) binary_depq = pickle.dumps(self.depq) depq_from_pickle = pickle.loads(binary_depq) self.assertEqual(self.depq.data, depq_from_pickle.data) self.assertEqual(self.depq.items, depq_from_pickle.items) self.assertEqual(type(depq_from_pickle.lock).__name__, 'lock') def test_json(self): for i in range(5): self.depq.insert([i], i) json_depq = json.dumps(self.depq.to_json()) depq_from_json = DEPQ.from_json(json_depq) self.assertEqual(self.depq.data, depq_from_json.data) self.assertEqual(self.depq.items, depq_from_json.items) self.assertEqual(type(depq_from_json.lock).__name__, 'lock')
return all(a in s for a in ALT) def has_upper(s): return any(c.isupper() for c in s) def has_lower(s): return any(c.islower() for c in s) def has_number(s): return any(c in NUM for c in s) def no_confusing(s): return all(c not in CONFUSING for c in s) if __name__ == '__main__': r = SystemRandom() while True: pwd_int = r.randrange(2**(SIZE * 8)) pwd = b64encode(pwd_int.to_bytes(SIZE, 'little'), altchars=ALT.encode('ascii')).decode('ascii') if (has_alts(pwd) and has_upper(pwd) and has_lower(pwd) and has_number(pwd) and no_confusing(pwd)): break print(pwd)
class RatchetProtocol: def __init__(self, local_sig_scheme, remote_sig_scheme, generator, group_order, modulus): self.local_sig_scheme = local_sig_scheme self.remote_sig_scheme = remote_sig_scheme self.random = SystemRandom() self.generator = generator self.group_order = group_order self.modulus = modulus self.remote_public_element = None self._new_private_element() self.received_message_ctr = 0 self.sent_message_ctr = 0 self.received_messages = dict() def _new_private_element(self): self.private_exponent = self.random.randrange(1, self.group_order) self.public_element = pow(self.generator, self.private_exponent, self.modulus) def _symmetric_key(self, remote_element): key = pow(remote_element, self.private_exponent, self.modulus) key = pbkdf2_hmac('sha256', encode_int(key, 256), b'SALT_FOR_34C3CTF', 256) return key def _encrypt_message(self, message): self._new_private_element() enc_key = self._symmetric_key(self.remote_public_element) iv = self.random.randrange(pow(2, 128)) ctr = Counter.new(128, initial_value=iv) cipher = AES.new(enc_key, AES.MODE_CTR, counter=ctr) ciphertext = cipher.encrypt(message.encode()) return self.public_element, iv, ciphertext def _decrypt_message(self, remote_element, iv, ciphertext): enc_key = self._symmetric_key(remote_element) ctr = Counter.new(128, initial_value=iv) cipher = AES.new(enc_key, AES.MODE_CTR, counter=ctr) plaintext = cipher.decrypt(ciphertext).decode() return plaintext def prepare_send_message(self, message): public_element, iv, ciphertext = self._encrypt_message(message) signed_data = encode_int(public_element, 256) + b"|" + encode_int( iv, 16) + b"|" + encode_bytes(ciphertext) signature = self.local_sig_scheme.sign_new(signed_data) data = signed_data + b"|" + encode_int(signature, 256) self.sent_message_ctr += 1 return data def on_recv_message(self, message): # check signature signed_data, signature = message.rsplit(b"|", 1) id = self.received_message_ctr + 1 dict_copy = self.received_messages.copy() dict_copy[id] = signed_data signature_valid = self.remote_sig_scheme.verify( dict_copy, decode_int(signature)) if not signature_valid: raise ValueError("invalid signature") # save and decrypt message self.received_messages[id] = signed_data remote_element, iv, ciphertext = signed_data.split(b"|") self.remote_public_element = decode_int(remote_element) plaintext = self._decrypt_message(self.remote_public_element, decode_int(iv), decode_bytes(ciphertext)) self.received_message_ctr += 1 return plaintext def __getstate__(self): """Called when this object is pickled: skip pickling self.random.""" args = dict(self.__dict__) # copy self.__dict__ del args['random'] return args def __setstate__(self, state): """Called when this object is unpickled: restore all data and self.random.""" self.__dict__ = state self.random = SystemRandom()
from random import SystemRandom # probably has unconventional characters but oh well CHARACTER_ARR = [chr(i) for i in range(33, 127)] amount = int(input('Amount of passwords: ')) length = int(input('Password length: ')) randomizer = SystemRandom() for _ in range(amount): password = '' length = length if length else 10 for _ in range(length): password += str(CHARACTER_ARR[randomizer.randrange(len(CHARACTER_ARR))]) print(password)
from Crypto.PublicKey import RSA from random import SystemRandom import os if __name__ == "__main__": random = SystemRandom() key = RSA.generate(1024) print("n =", key.n) print("e =", key.e) m0 = int.from_bytes(os.urandom(64).hex().encode(), "big") m1 = int.from_bytes(os.urandom(64).hex().encode(), "big") x0 = random.randrange(key.n) x1 = random.randrange(key.n) print("x0 =", x0) print("x1 =", x1) v = int(input("v = ")) m0_ = (m0 + pow(v - x0, key.d, key.n)) % key.n m1_ = (m1 + pow(v - x1, key.d, key.n)) % key.n print("m0_ =", m0_) print("m1_ =", m1_) guess0 = int(input("m0 = ")) guess1 = int(input("m1 = ")) if guess0 == m0: print(open("flag1").read()) if guess1 == m1: print(open("flag2").read())
class BB84(Application): def __init__(self, username): super().__init__(username) self.RNG = SystemRandom() # a high quality random number generator self.basis_bits = [] self.prekey_bits = [] self.key_bits = [] self.bases_sent = False def send_qubit(self, remote_user): super().send_qubit(remote_user) def receive_qubit( self, qubit): # a state has been teleported onto a local qubit. print("received qubit", qubit) super().receive_qubit(qubit) # measure return def send_bases(self, remote_user): msg = { 'msg': "forward to user", # this is the standard. Document it somewhere. 'sender': self.username, 'receiver': remoteUser, 'type': "basis bits", 'data': self.basis_bits } self.send_message(self.quantum_internet, msg) def receive_bases(self, bases): for i in range(len(bases)): if bases[i] == self.basis_bits[i]: self.key_bits.append(self.prekey_bits[i]) self.handle_exchange_complete() def initiate_key_exchange(self, remote_user, n=10): # check that the user is connected to the network. if not self.quantum_internet.check_IsOnline(remote_user): print("user", remote_user, "is not connected to the network.") return self.basis_bits = self.randomBits(n) self.prekey_bits = self.randomBits(n) for (prekey, basis) in zip(prekey_bits, basis_bits): if basis == 0: self.send_qubit(basis(2, prekey), remote_user) else: self.send_qubit(H * basis(2, prekey), remote_user) # wait for the remoteUser to acknowledge receipt and measurement def send_message(self, obj, msg): obj.handle_message(msg) def handle_message(self, msg): if super().handle_message(msg) == 1: return # application has already handled the message if msg['msg'] == "msg from user": if msg['type'] == "basis bits": self.receive_bases(msg['data']) if not self.bases_sent: self.send_bases(msg['sender']) if msg['type'] == "qubits received": self.send_bases(msg['sender']) else: print("BB84 application received unknown message \"" + msg['msg'] + "\"") def handle_exchange_complete(self): print("Key exchange complete:", key) def check_IfEve(self, pruned_key_bits): # tests some bits of the key at random to check # if there was an eavesdropper. pass def randomBits(self, n): return [self.RNG.randrange(2) for i in range(n)]
import os from random import SystemRandom import base64 import hmac if len(sys.argv) < 2: sys.stderr.write('Please include username as an argument.\n') sys.exit(0) username = sys.argv[1] #This uses os.urandom() underneath cryptogen = SystemRandom() #Create 16 byte hex salt salt_sequence = [cryptogen.randrange(256) for i in range(16)] hexseq = list(map(hex, salt_sequence)) salt = "".join([x[2:] for x in hexseq]) #Create 32 byte b64 password password = base64.urlsafe_b64encode(os.urandom(32)) digestmod = hashlib.sha256 if sys.version_info.major >= 3: password = password.decode('utf-8') digestmod = 'SHA256' m = hmac.new(bytearray(salt, 'utf-8'), bytearray(password, 'utf-8'), digestmod) result = m.hexdigest()
def generate_keypair(curve, p, n): sysrand = SystemRandom() d = sysrand.randrange(1, n) q = curve.mult(p, d) return d, q
def generate_cryptsafe_code(n, alpha): " Geneate a n digit cryptographically secure ID with given alphabet " cryptogen = SystemRandom() return "".join( [str(alpha[cryptogen.randrange(len(alpha))]) for i in range(n)])
class BiasedRandomSequence: """ >>> my_list = BiasedRandomSequence() >>> prob, value = 50, 3 >>> my_list.append(prob, value) >>> my_list[0] 3 >>> my_list.append(50, 6) >>> my_list [3, 6] >>> len(my_list) 2 >>> my_list.random_get() in [3, 6] True """ def __init__(self, *new_items, insert_key=None): self._data_dict = dict() self._index_to_range_dict = dict() self._max_prob_index = 0 self._randomizer = SystemRandom() if insert_key is not None: for item in new_items: self.append(insert_key(item), item) @property def max_index(self): return len(self) - 1 def __len__(self): return len(self._data_dict) def __repr__(self): """ >>> my_list = BiasedRandomSequence() >>> my_list.append(10, 1) >>> my_list.append(20, 2) >>> my_list.append(30, 3) >>> my_list.append(30, 4) >>> my_list [1, 2, 3, 4] """ return str([self[i] for i in range(len(self))]) def __getitem__(self, index): """ >>> my_list = BiasedRandomSequence() >>> my_list.append(10, 1) >>> my_list.append(20, 2) >>> my_list.append(30, 3) >>> my_list.append(30, 4) >>> my_list[0] 1 >>> my_list[1] 2 >>> my_list[4] Traceback (most recent call last): ... IndexError: index out of bounds """ if index >= len(self): raise IndexError("index out of bounds") return self._data_dict[self._index_to_range_dict[index]] def __iter__(self): return BRSequenceIterator(self) def _prob_to_range(self, prob): return range(self._max_prob_index, prob + self._max_prob_index) def append(self, prob, value): self._data_dict[self._prob_to_range(prob)] = value self._index_to_range_dict[self.max_index] = self._prob_to_range(prob) self._max_prob_index += prob def random_get(self): prob_index = self._randomizer.randrange(self._max_prob_index) for key in self._data_dict.keys(): if prob_index in key: return self._data_dict[key]
def test_check_valid_path(self): # success case: input the valid path path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.connector_token_list[1] ] self.network_score._require_valid_path(path) # failure case: input path whose length under 3 invalid_path = [ self.connector_token_list[0], self.flexible_token_address_list[0] ] self.assertRaises(RevertException, self.network_score._require_valid_path, invalid_path) # failure case: input path whose length is more than 21 random = SystemRandom() # use random data to avoid same address is made invalid_path = [ Address.from_string("cx" + str(random.randrange(10)) + str(random.randrange(10)) * 39) in range(0, 22) ] self.assertRaises(RevertException, self.network_score._require_valid_path, invalid_path) # failure case: input path whose length is even invalid_path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.connector_token_list[1], self.flexible_token_address_list[1] ] self.assertRaises(RevertException, self.network_score._require_valid_path, invalid_path) # failure case: input path which has the same flexible token address in it invalid_path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.connector_token_list[1], self.flexible_token_address_list[0], self.connector_token_list[1] ] self.assertRaises(RevertException, self.network_score._require_valid_path, invalid_path) # success case: input path which has the same flexible token address in the 'from' or 'to' position in it # path: [connector0 - flexible token0 - flexible token1 - flexible token2, flexible token0] path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.flexible_token_address_list[1], self.flexible_token_address_list[2], self.flexible_token_address_list[0] ] self.network_score._require_valid_path(path) # success case: input path which has the same flexible tokens that only exist in 'from' or 'to' in it path = [ self.flexible_token_address_list[0], self.flexible_token_address_list[1], self.connector_token_list[0], self.flexible_token_address_list[2], self.flexible_token_address_list[0] ] self.network_score._require_valid_path(path)
def Hash(input): cryptogen = SystemRandom() salt = [cryptogen.randrange(10) for i in range(32)] salt = ''.join(str(i) for i in salt) hashval = hashlib.md5(salt + input).hexdigest() return hashval, salt
class tbnumerics: def __init__(self, _verbose=False, _debug=False): self.MOD_PREFIX = "MODULE tbencryptlib::tbnumerics" self._mrpt_num_trials = 5 # number of bases to test self.DEBUG = _debug self.VERBOSE = _verbose self.sysrandom = SystemRandom() ''' PRIVATE ''' def __dbgprnt(self, str): if True == self.DEBUG: sys.stdout.write(self.MOD_PREFIX + ":" + str + '\n') def __verbose(self, str): if True == self.VERBOSE: sys.stdout.write(self.MOD_PREFIX + ":" + str + '\n') def __errprnt(self, str): sys.stderr.write(self.MOD_PREFIX + "ERROR: " + str + '\n') def __is_probable_prime(self, n): """ Miller-Rabin primality test. A return value of False means n is certainly not prime. A return value of True means n is very likely a prime. """ assert n >= 2 # special case 2 # we exclude 2, since it is not useful for key generation if n == 2: return False # ensure n is odd if n % 2 == 0: return False # write n-1 as 2**s * d # repeatedly try to divide n-1 by 2 s = 0 d = n - 1 while True: quotient, remainder = divmod(d, 2) if remainder == 1: break s += 1 d = quotient assert (2**s * d == n - 1) # test the base a to see whether it is a witness # for the compositeness of n def try_composite(a): if pow(a, d, n) == 1: return False for i in range(s): if pow(a, 2**i * d, n) == n - 1: return False return True # n is definitely composite for i in range(self._mrpt_num_trials): # a = random.randrange(2, n) a = self.sysrandom.randrange(2, n) if try_composite(a): return False return True # no base tested showed n as composite ''' PUBLIC ''' ''' FACTORING ''' def factor_powers_of_p(self, n, p): power_list = [] ''' start with rn = n find the highest possible exponent e go through the exponents less than e, the coefficient of each exponent is the quotient n//(p**e) go to the next lower e with the remainder n%(p**e) ''' try: rn = int(n) rp = int(p) except: self.__errprnt("::factor_powers_of_p:inputs must be integer type") raise # find highest exponent e = 0 while p**e <= n: e = e + 1 e = e - 1 while e: power_list.append(n // (p**e)) n = n % (p**e) e = e - 1 power_list.append(n) return power_list def factor_powers_of_two(self, n): power_list = [] ''' start with rn = n divide: let ri = rn/2 until ri becomes 1 push the number of times divided onto the array test rx = rn - 2^i if this is: > 1 then let rn = rx == 1 push 0 on the array and return == 0 return ''' try: rn = int(n) except: self.__errprnt("::factor_powers_of_two:input must be integer type") raise while rn > 1: rx = int(rn) i = 0 while rx > 1: ri = rx // 2 if ri >= 1: i += 1 rx = ri if rx == 1: power_list.append(i) rn = rn - (2**i) if rn == 1: power_list.append(0) return power_list ''' PRIME FACTORIZATION ''' def prime_factors(self, n): i = 2 factors = [] while i * i <= n: if n % i: i += 1 else: n //= i factors.append(i) if n > 1: factors.append(n) return factors ''' PRIME FACTORIZATION 2 start at the given i ''' def prime_factors2(self, n, _i): ## i = 2 i = _i factors = [] while i * i <= n: if n % i: i += 1 else: n //= i factors.append(i) if n > 1: factors.append(n) return factors ''' EUCLIDEAN ALGORITHMS - iterative Extended Euclidean Algorithm iterative version ''' def egcd_iter(self, a, b): x, y, u, v = 0, 1, 1, 0 while a != 0: q, r = b // a, b % a m, n = x - u * q, y - v * q b, a, x, y, u, v = a, r, u, v, m, n gcd = b return gcd, x, y ''' EUCLIDEAN ALGORITHM - recursive Extended Euclidean Algorithm the recursive version will blow the stack ("max recusion depth") with bit lengths of about 2048 ''' def egcd(self, a, b): if a == 0: return (b, 0, 1) else: g, y, x = self.egcd(b % a, a) return (g, x - (b // a) * y, y) ''' GREATEST COMMON DIVISOR ''' def greatest_common_divisor(self, a, b): try: aint = int(a) bint = int(b) except: self.__errprnt( "::greatest_common_divisor:inputs must be integer type") raise if a == b: return a if a > b: self.greatest_common_divisor(b, a) while True: rn = b % a if rn == 0: return a else: b = a a = rn ''' MODULAR INVERSE ''' def modinv(self, a, m): g, x, y = self.egcd_iter(a, m) if g != 1: raise Exception('tbencryptlib:tbnumerics::modinv:modular ' + 'inverse does not exist') else: return x % m ''' IS_PRIME ''' def is_prime(self, prime_candidate): try: pc = abs(int(prime_candidate)) except: self.__errprnt('::is_prime:inputs must be integer type') raise if pc == 1: return False b = self.__is_probable_prime(pc) return b ''' GEN_NBIT_PRIME Generate a prime such that the magnitude is a certain number of bits ''' def gen_nbit_prime(self, nbits): try: inum = int(nbits) except: self.__errprnt("::gen_nbit_prime: " + str(nbits) + " is not a number!") raise if inum == 0: raise Exception("tbnumerics:gen_nbit_prime: nbits is ZERO") #this seems kinda arbitrary, if caller wants pain go for it #if inum > 4096: # raise Exception("tbencryptlib::gen_nbit_prime: Too many bits, should be less than or equal to 4096") lo = 2**(inum - 1) hi = 2**(inum) self.__dbgprnt("gen_nbit_prime: gen prime between 0x" + format(lo, '0x') + " and 0x" + format(hi, '0x')) # rand_p = random.randint(lo, hi-1) rand_p = self.sysrandom.randint(lo, hi - 1) while not self.__is_probable_prime(rand_p): if self.__is_probable_prime(rand_p): break else: if rand_p < hi - 1: rand_p += 1 else: # rand_p = random.randint(lo, hi-1) rand_p = self.sysrandom.randint(lo, hi - 1) one_bits = bin(rand_p).count("1") if float(one_bits) <= float(inum) / 2.0: bit_entropy = float(one_bits) / float(inum) else: bit_entropy = (float(inum) - float(one_bits)) / float(inum) self.__dbgprnt("Algorithm gen " + str(inum) + "-bit prime: 0x" + format(rand_p, '0x') + " is prime: Entropy: " + str(bit_entropy)) return (rand_p, bit_entropy) ''' GEN_PRIME_CEIL Generate a prime such that the magnitude is less than a certain number ''' def gen_prime_ceil(self, ceil): nmin = 3 try: inum = int(ceil) except: self.__errprnt("::gen_prime_ceil: " + str(ceil) + " is not a number!") raise if inum < nmin: raise Exception("tbnumerics:gen_prime_ceil: ceil is too small") #this seems kinda arbitrary, if caller wants pain go for it #if inum > 4096: # raise Exception("tbencryptlib::gen_nbit_prime: Too many bits, should be less than or equal to 4096") ## lo = 2**(inum-1) hi = inum self.__dbgprnt("gen_prime_ceil: gen prime less than 0x" + format(hi, '0x')) # rand_p = random.randint(nmin, hi-1) rand_p = self.sysrandom.randint(nmin, hi - 1) while not self.__is_probable_prime(rand_p): if self.__is_probable_prime(rand_p): break else: if rand_p < hi - 1: rand_p += 1 else: # rand_p = random.randint(nmin, hi-1) rand_p = self.sysrandom.randint(nmin, hi - 1) return rand_p ''' BLOCK ENCRYPTION ROUTINES the next number after num that is a even multiple of blksize ''' def next_multiple_of(self, num, blksize): b_num = 0 b_blk = 0 try: b_num = int(num) b_blk = int(blk) except: return 0 return b_num + (b_blk - b_num % b_blk) ''' SUNDRY UTILS ''' def sum_of_digits(self, _x): x = 0 try: x = int(_x) except: print("sum_of_digits: _x must be integer") return -1 total = 0 xs = str(x) for c in xs: total += int(c) return total ''' BIT LENGTH OF A NUMBER ''' def bit_length(self, _x): x = 0 try: x = int(_x) except: print("sum_of_digits: _x must be integer") return -1 return math.ceil(math.log(x, 2)) ''' DEBUGGING ''' def set_debug(self, b_dbg): if True == b_dbg: self.DEBUG = True else: self.DEBUG = False def set_verbose(self, b_vrb): if True == b_vrb: self.VERBOSE = True else: self.VERBOSE = False
from random import SystemRandom def guess_num_check(num: int): if num % 2 == 0: print("Its a even number") elif num % 2 != 0: print("Its a odd number") # score = 10 def score_keep(score: int): score -= 1 print(score) if __name__ == "__main__": random_gen = SystemRandom() X = random_gen.randrange(100) hint = input("Hint needed? (Y or N) : ", ) hint = hint.lower() # score = 10 if hint == "y": score_keep(10)
class CodeBasedEncryptionScheme(object): @classmethod def new(cls, bitlength=48): key = cls.keygen(bitlength) return cls(key) def __init__(self, key): self.key = key self.key_length = len(self.key) self.random = SystemRandom() @classmethod def keygen(cls, bitlength): key = SystemRandom().getrandbits(bitlength) key = BitVector(size=bitlength, intVal=key) return key def add_encoding(self, message): message = int.from_bytes(message, 'big') message = BitVector(size=self.key_length // 3, intVal=message) out = BitVector(size=self.key_length) for i, b in enumerate(message): out[i * 3 + 0] = b out[i * 3 + 1] = b out[i * 3 + 2] = b return out def decode(self, message): out = BitVector(size=self.key_length // 3) for i in range(self.key_length // 3): if message[i * 3] == message[i * 3 + 1]: decoded_bit = message[i * 3] elif message[i * 3] == message[i * 3 + 2]: decoded_bit = message[i * 3] elif message[i * 3 + 1] == message[i * 3 + 2]: decoded_bit = message[i * 3 + 1] else: assert (False) out[i] = decoded_bit return bitvector_to_bytes(out) def encrypt(self, message): message = self.add_encoding(message) columns = [ BitVector(size=self.key_length, intVal=self.random.getrandbits(self.key_length)) for _ in range(self.key_length) ] # compute the noiseless mask y = matrix_vector_multiply(columns, self.key) # mask the message y ^= message # add noise: make a third of all equations false for i in range(self.key_length // 3): noise_index = self.random.randrange(inverse_error_probability) y[i * 3 + noise_index] ^= 1 columns = [bitvector_to_bytes(c) for c in columns] columns = b"".join(columns) return columns + bitvector_to_bytes(y) def decrypt(self, ciphertext): y = ciphertext[-self.key_length // 8:] columns = ciphertext[:-self.key_length // 8] columns = [ bitvector_from_bytes(columns[i:i + self.key_length // 8]) for i in range(0, len(columns), self.key_length // 8) ] y = bitvector_from_bytes(y) y ^= matrix_vector_multiply(columns, self.key) result = self.decode(y) return result
def random(self): cryptogen = SystemRandom() # Generate a cryptosafe number between 1 and 6 return cryptogen.randrange(1, 6)
f.close() # # fetch new followers_count and write to csv ############################################################### logging.info('fetching followers_count\'s and writing to file...') timestr = time.strftime("%Y%m%d-%H%M%S") filename = "followers_counts_%s_r.csv" % timestr nf = open(filename, 'w') wtr = csv.writer(nf, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL, lineterminator='\n') cryptogen = SystemRandom() while True: u = u_ids[cryptogen.randrange(len(u_ids) - 1)] u_ids.remove(u) timestr = time.strftime("%Y%m%d-%H%M%S") try: user = api.get_user(u) wtr.writerow([u, user._json['followers_count'], timestr]) except tweepy.error.TweepError, e: if 'User not found' in e.message[0]['message']: wtr.writerow([u, 'n', timestr]) nf.flush() nf.close()
def roll_dice(n): """Roll n 6-sided dice""" sys_random = SystemRandom() return [sys_random.randrange(1, 7) for i in range(n)]
def __init__(self, board_size): secure_random = SystemRandom() self.zArray = [[ secure_random.randrange(1000000000), secure_random.randrange(1000000000) ] for i in range(board_size**2)]
#Note: this is for python 3 #Note2: This one is cryptographically safe from random import SystemRandom ran = SystemRandom() # build a character array of uppercase characters (A-Z) and append '9' chars = [i for i in map(chr, range(65, 91))] chars.append('9') # seed = an array of 81 random characters from the chararacter array seed = [chars[ran.randrange(len(chars))] for x in range(81)] # print the seed for x in seed: print(x, end="")
def _get_random_value(cls, min_port, max_port): cryptogen = SystemRandom() return cryptogen.randrange(min_port, max_port)
from random import SystemRandom numbers = {} for _ in range(6000): random_dig = SystemRandom() a_dig = random_dig.randrange(1, 7) if a_dig not in numbers: numbers[a_dig] = 0 elif a_dig in numbers: numbers[a_dig] += 1 print(numbers) f = open('test.txt', 'a') f.write(str(numbers) + '\n')