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
def crypto_choice(rng: random.SystemRandom, choices: Sequence):
return choices[rng.randrange(0, len(choices))]
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)
def generate_keypair(curve, p, n):
sysrand = SystemRandom()
d = sysrand.randrange(1, n)
q = curve.mult(p, d)
return d, q
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)]
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()
#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')
