def Brent_Cycle_finding_method(N : int):
random = SystemRandom()
if N % 2 == 0:
return 2
y, c, m = random.randint(1, N - 1), random.randint(1, N - 1), random.randint(1, N - 1)
g, r, q = 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = ((y * y) % N + c) % N
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = ((y * y) % N + c) % N
q = q * (abs(x - y)) % N
g = gcd(q, N)
k = k + m
r *= 2
if g == N:
while True:
ys = ((ys * ys) % N + c) % N
g = gcd(abs(x - ys), N)
if g > 1:
break
return g
def gen_votes(self):
cryptogen = SystemRandom()
votings = [cryptogen.randint(1, 5000) for i in range(10)]
users = [cryptogen.randint(3, 5002) for i in range(50)]
for v in votings:
a1 = str(cryptogen.randint(2, 500))
b1 = str(cryptogen.randint(2, 500))
a2 = str(cryptogen.randint(2, 500))
b2 = str(cryptogen.randint(2, 500))
votacion = self.gen_voting(v)
random_user = cryptogen.choice(users)
user = self.get_or_create_user(random_user)
self.login(user=user.username)
census = Census(voting_id=v, voter_id=random_user)
census.save()
question = votacion.question.all()
data = {
"voting": v,
"voter": random_user,
"question_id": question[0].id,
"vote": [{
"a": a1,
"b": b1
}, {
"a": a2,
"b": b2
}]
}
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 200)
self.logout()
return votings, users, question[0].id
def get_report(survey_id, collection_exercise_id):
rand_gen = SystemRandom()
sample_size = rand_gen.randint(100, 1000)
accounts_enrolled = rand_gen.randint(0, sample_size)
accounts_pending = rand_gen.randint(0, (sample_size - accounts_enrolled) //
10)
downloads = rand_gen.randint(0, accounts_enrolled)
uploads = rand_gen.randint(0, downloads)
response = {
'metadata': {
'collectionExerciseId': collection_exercise_id,
'timeUpdated': datetime.now().timestamp()
},
'report': {
'inProgress': downloads - uploads,
'accountsPending': accounts_pending,
'accountsEnrolled': accounts_enrolled,
'notStarted': sample_size - downloads,
'completed': uploads,
'sampleSize': sample_size
}
}
return Response(json.dumps(response), content_type='application/json')
def test_stress(self):
"""
Runs a large number of threads doing operations with resources
checked out, ensuring properties of the pool.
"""
rand = SystemRandom()
n = rand.randint(1, 400)
passes = rand.randint(1, 20)
rounds = rand.randint(1, 200)
breaker = rand.uniform(0, 1)
pool = EmptyListPool()
def _run():
for i in range(rounds):
with pool.transaction() as a:
self.assertEqual([], a)
a.append(currentThread())
self.assertEqual([currentThread()], a)
for p in range(passes):
self.assertEqual([currentThread()], a)
if rand.uniform(0, 1) > breaker:
break
a.remove(currentThread())
threads = []
for i in range(n):
th = Thread(target=_run)
threads.append(th)
th.start()
for th in threads:
th.join()
def test_stress(self):
"""
Runs a large number of threads doing operations with resources
checked out, ensuring properties of the pool.
"""
rand = SystemRandom()
n = rand.randint(1, 400)
passes = rand.randint(1, 20)
rounds = rand.randint(1, 200)
breaker = rand.uniform(0, 1)
pool = EmptyListPool()
def _run():
for i in range(rounds):
with pool.transaction() as a:
self.assertEqual([], a)
a.append(currentThread())
self.assertEqual([currentThread()], a)
for p in range(passes):
self.assertEqual([currentThread()], a)
if rand.uniform(0, 1) > breaker:
break
a.remove(currentThread())
threads = []
for i in range(n):
th = Thread(target=_run)
threads.append(th)
th.start()
for th in threads:
th.join()
def get_report(survey_id, collection_exercise_id):
rand_gen = SystemRandom()
sample_size = rand_gen.randint(100, 1000)
accounts_enrolled = rand_gen.randint(0, sample_size)
accounts_pending = rand_gen.randint(0, (sample_size - accounts_enrolled) //
10)
downloads = rand_gen.randint(0, accounts_enrolled)
uploads = rand_gen.randint(0, downloads)
response = {
"metadata": {
"collectionExerciseId": collection_exercise_id,
"timeUpdated": datetime.now().timestamp()
},
"report": {
"inProgress": downloads - uploads,
"accountsPending": accounts_pending,
"accountsEnrolled": accounts_enrolled,
"notStarted": sample_size - downloads,
"completed": uploads,
"sampleSize": sample_size,
},
}
return Response(json.dumps(response), content_type="application/json")
def test_basePoint(self):
r = SystemRandom()
for i in range(10):
p = getRandPrime(5)
while p <= 10:
p = getRandPrime(5)
e = ecc.ECC(r.randint(1, 100), r.randint(1, 100), p)
G = e.G
self.assertTrue(e.isInCurve(G))
def genKeys(nbits):
p,nchecks = findPrime(nbits)
r1 = SystemRandom(time.time())
r2 = SystemRandom(time.time())
a = r1.randint(1,p-2)
k = r2.randint(1,p-2)
pubkey = (p,a,pow(a,k,p))
prikey = k
return (pubkey,prikey)
def test_listPointGenerator(self):
r = SystemRandom()
for i in range(10):
p = getRandPrime(5)
while p <= 10:
p = getRandPrime(5)
e = ecc.ECC(r.randint(1, 100), r.randint(1, 100), p)
for point in e.listPointGenerator():
self.assertTrue(e.isInCurve(point))
class Handpar_Process:
"""
Handpar randomizer: see Cli() for usage.
"""
def __init__(self, **lopts):
self.random = SystemRandom()
if len(lopts) > 0:
self.update(lopts)
def update(self, lopts):
self.__dict__.update(lopts)
self.parangle = self.markovwalk(getattr(self, "minparangle", 0),
getattr(self, "maxparangle", 0))
@autocount
def __call__(self, par):
return "\\begin{handparfull}{%d}{%.2f}\n%s\n\end{handparfull}" % (
next(self.parangle),
self.random.uniform(self.minparscale, self.maxparscale),
fill(" ".join(
[(self.rotatebox(word) if state else word)
for state, word in izip(
self.bernouilli(self.freqword),
[
self.wordcount(i)
for i in re.split("\s+", par.group(1)) if len(i) > 0
],
)])),
)
@autocount
def wordcount(self, word):
return word
@autocount
def rotatebox(self, word):
return "\\handword{%d}{%s}" % (
self.randpick((self.lowwordangle, self.highwordangle)),
word,
)
def bernouilli(self, freq):
while True:
yield True if (self.random.uniform(0, 1) <= freq) else False
def markovwalk(self, a, b):
pos = self.random.randint(a, b)
while True:
step = self.random.randint(-1, 1)
pos += step
if (pos < a) or (pos > b):
pos -= step
yield pos
def randpick(self, pick):
return pick[self.random.randint(0, len(pick) - 1)]
def random_non_trivial_unit(n, max_tries=100):
r = SystemRandom()
v = r.randint(2, n - 2)
tries = 0
while GCD(v, n) != 1 and (max_tries is None or tries < max_tries):
v = r.randint(2, n - 2)
tries += 1
if max_tries is not None and tries >= max_tries:
raise ValueError("could not find a random non-trivial unit")
return v
def plot_custom(c_pattern, all_points, w, h):
w -= 2
h -= 2
randGenerator = SystemRandom()
points = [(randGenerator.randint(0,
w - 1), randGenerator.randint(0, h - 1))
for _ in range(all_points)]
for p in points:
c_pattern.create_oval([(p[0] - 2, p[1] - 2), (p[0] + 2, p[1] + 2)],
tag='grid_line',
fill='red')
def make_cert():
"""Generate and return a public key PEM and a secret key PEM."""
secretkey = rsa.generate_private_key(public_exponent=65537,
key_size=2048,
backend=default_backend())
secretkey_pem = secretkey.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption())
f = make_fields()
attrs = []
if f.country:
attrs.append(x509.NameAttribute(NameOID.COUNTRY_NAME, f.country))
if f.state:
attrs.append(
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, f.state))
if f.locality:
attrs.append(x509.NameAttribute(NameOID.LOCALITY_NAME, f.locality))
if f.org:
attrs.append(x509.NameAttribute(NameOID.ORGANIZATION_NAME, f.org))
if f.unit:
attrs.append(
x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, f.unit))
if f.common:
attrs.append(x509.NameAttribute(NameOID.COMMON_NAME, f.common))
rng = SystemRandom()
date_from = datetime.utcnow() - timedelta(
days=f.delta * rng.randint(0, 80) / 100,
hours=rng.randint(0, 23),
minutes=rng.randint(0, 59),
seconds=rng.randint(0, 59),
)
dns_list = []
for name in f.dns_names:
dns_list.append(x509.DNSName(name))
subject = issuer = x509.Name(attrs)
cert = x509.CertificateBuilder() \
.subject_name(subject) \
.issuer_name(issuer) \
.public_key(secretkey.public_key()) \
.serial_number(x509.random_serial_number()) \
.not_valid_before(date_from) \
.not_valid_after(date_from + timedelta(days=f.delta)) \
.add_extension(x509.SubjectAlternativeName(dns_list), critical=False) \
.sign(secretkey, hashes.SHA256(), default_backend())
publickey_pem = cert.public_bytes(serialization.Encoding.PEM)
return (publickey_pem, secretkey_pem)
def generate_question(self):
"""Generate random question."""
generator = SystemRandom()
operation = generator.choice(self.operators)
first = generator.randint(self.interval[0], self.interval[1])
second = generator.randint(self.interval[0], self.interval[1])
# We don't want negative answers
if operation == '-':
first += self.interval[1]
return ' '.join((str(first), operation, str(second)))
def BuildCommitmentPrivate(v, private_bit_commitments, target_bits=64):
#Sort bit commitments
pc, index = zip(*sorted(
zip(private_bit_commitments,
list(range(0, len(private_bit_commitments))))))
#Find transition from commitments to 0 to commitments to 1
one_start_index = 0
while (pc[one_start_index][0] == 0):
one_start_index += 1
indices_zero = list(range(0, one_start_index))
indices_one = list(range(one_start_index, len(pc)))
#Build commitments
sr = SystemRandom()
indices = [0] * target_bits
total_bf = 0
bit_flag = (1 << target_bits - 1)
for i in range(0, target_bits):
total_bf = total_bf * 2 % bn128.curve_order
#If out of indices, refresh pool
if len(indices_zero) == 0 or len(indices_one) == 0:
indices_zero = list(range(0, one_start_index))
indices_one = list(range(one_start_index, len(pc)))
if v & bit_flag == 0:
#Pick random zero commitment index
r = sr.randint(0, len(indices_zero) - 1)
indices[i] = index[indices_zero[r]]
#Remove index from further choices
indices_zero = indices_zero[:r] + indices_zero[r + 1:]
else:
#Pick random one commitment index
r = sr.randint(0, len(indices_one) - 1)
indices[i] = index[indices_one[r]]
#Remove index from further choices
indices_one = indices_one[:r] + indices_one[r + 1:]
#Update total_bf
total_bf = total_bf + private_bit_commitments[
indices[i]][1] % bn128.curve_order
bit_flag >>= 1
#Create Proof
return indices, total_bf
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 test_add(self):
r = SystemRandom()
for i in range(10):
p = getRandPrime(5)
while p <= 10:
p = getRandPrime(5)
e = ecc.ECC(r.randint(1, 100), r.randint(1, 100), p)
all_points = list(e.listPointGenerator())
for j in range(100):
point1 = r.choice(all_points)
point2 = r.choice(all_points)
point = e.add(point1, point2)
self.assertEqual(e.isInCurve(point), True)
class MultiElGamal(object):
def __init__(self, p, g):
self.p = p
self.q = (p - 1) / 2
self.g = g
self.random_source = SystemRandom()
def generate_private_key(self):
return self.random_source.randint(2, self.q - 1)
def generate_public_key(self, x):
return pow(self.g, x, self.p)
def generate_shares(self, x, share_count, recovery_threshold):
# generate a list of coefficients, of length recovery_threshold, in the form:
# [x, randint(0, q - 1), randint(0, q - 1) ...]
coefficients = [x] + [
self.random_source.randint(0, self.q - 1)
for _ in range(recovery_threshold - 1)
]
# use the coefficients to construct a polynomial, of degree recovery_threshold - 1,
# with y-intercept of x, in the form:
# coefficients[0] * i ^ 0 + coefficients[1] * i ^ 1 + coefficients[2] * i ^ 2 ...
def recovery_polynomial(i):
return sum(coefficient * pow(i, j)
for j, coefficient in enumerate(coefficients))
# generate shares, in the form:
# [recovery_polynomial(1), recovery_polynomial(2), ..., recovery_polynomial(share_count)]
shares = [recovery_polynomial(i + 1) for i in range(share_count)]
# generate commitments for each random coefficient, in the form:
# [g ^ coefficients[1] % p, g ^ coefficients[2] % p ...]
commitments = [
pow(self.g, coefficient, self.p)
for coefficient in coefficients[1:]
]
return shares, commitments, coefficients
def confirm_share(self, share_input, share_output, commitments):
secret_share_check = pow(self.g, share_output, self.p)
commitment_check = modular_product(
(pow(commitment, pow(share_input, i), self.p)
for i, commitment in enumerate(commitments)), self.p)
return secret_share_check == commitment_check
def combine_public_keys(self, y_list):
return modular_product([y for y in y_list], self.p)
def populate(self, *excludePSets):
"""
_populate_
generate a bunch of seeds and stick them into this service
This is the lazy user method.
Optional args are names of PSets to *NOT* alter seeds.
Eg:
populate() will set all seeds
populate("pset1", "pset2") will set all seeds but not those in
psets named pset1 and pset2
"""
import random
from random import SystemRandom
_inst = SystemRandom()
_MAXINT = 900000000
# //
# // count seeds and create the required number of seeds
#//
newSeeds = [ _inst.randint(1, _MAXINT)
for i in range(self.countSeeds())]
self._lockedSeeds = list(excludePSets)
self.insertSeeds(*newSeeds)
self._lockedSeeds = []
return
def csprng(low, high, offset=0):
rng = SystemRandom()
rnum = rng.randint(low, high - 1) + offset
if rnum < 0:
print("[-] Error: Random number generator returned out of bounds.")
return None
return rnum
def random_mac(value, seed=None):
''' takes string prefix, and return it completed with random bytes
to get a complete 6 bytes MAC address '''
if not isinstance(value, string_types):
raise AnsibleFilterError('Invalid value type (%s) for random_mac (%s)' % (type(value), value))
value = value.lower()
mac_items = value.split(':')
if len(mac_items) > 5:
raise AnsibleFilterError('Invalid value (%s) for random_mac: 5 colon(:) separated items max' % value)
err = ""
for mac in mac_items:
if len(mac) == 0:
err += ",empty item"
continue
if not re.match('[a-f0-9]{2}', mac):
err += ",%s not hexa byte" % mac
err = err.strip(',')
if len(err):
raise AnsibleFilterError('Invalid value (%s) for random_mac: %s' % (value, err))
if seed is None:
r = SystemRandom()
else:
r = Random(seed)
# Generate random int between x1000000000 and xFFFFFFFFFF
v = r.randint(68719476736, 1099511627775)
# Select first n chars to complement input prefix
remain = 2 * (6 - len(mac_items))
rnd = ('%x' % v)[:remain]
return value + re.sub(r'(..)', r':\1', rnd)
def populate(self, *excludePSets):
"""
_populate_
generate a bunch of seeds and stick them into this service
This is the lazy user method.
Optional args are names of PSets to *NOT* alter seeds.
Eg:
populate() will set all seeds
populate("pset1", "pset2") will set all seeds but not those in
psets named pset1 and pset2
"""
import random
from random import SystemRandom
_inst = SystemRandom()
_MAXINT = 900000000
# //
# // count seeds and create the required number of seeds
#//
newSeeds = [ _inst.randint(1, _MAXINT)
for i in range(self.countSeeds())]
self._lockedSeeds = list(excludePSets)
self.insertSeeds(*newSeeds)
self._lockedSeeds = []
return
def rabin_miller(n, t=7):
is_prime = True
if n < 6:
return [
not is_prime, not is_prime, is_prime, is_prime, not is_prime,
is_prime
][n]
elif not n & 1:
return not is_prime
def check(a, s, r, n):
x = pow(a, r, n)
if x == 1:
return is_prime
for i in range(s - 1):
if x == n - 1:
return is_prime
x = pow(x, 2, n)
return x == n - 1
# Find s and r such as n - 1 = 2^s * r
s, r = 0, n - 1
while r & 1:
s = s + 1
r = r >> 1
rand = SystemRandom()
for i in range(t):
a = rand.randint(2, n - 1)
if not check(a, s, r, n):
return not is_prime
return is_prime
def generate_question(self):
"""Generate random question."""
generator = SystemRandom()
operation = generator.choice(self.operators)
first = generator.randint(self.interval[0], self.interval[1])
second = generator.randint(self.interval[0], self.interval[1])
# We don't want negative answers
if operation == '-':
first += self.interval[1]
return ' '.join((
str(first),
operation,
str(second)
))
class Dice:
"""A Class that mimics a physical dice used in board games."""
def __init__(self):
super().__init__()
self._seed = int(time() * 100_000)
self._generator = SystemRandom(self._seed)
self.last_result = None
return
@property
def roll(self):
self.last_result = self._generator.randint(1, 6)
return self.last_result
def __str__(self):
s = "Dice Object" if self.last_result is None else \
"Dice that last rolled to {}".format(self.last_result)
return s
def __repr__(self):
return "Dice()"
@property
def picture_file_name(self):
folder = Path(__file__).absolute().parent
file_name = folder / Path("config/D{}.png".format(self.last_result))
file_name = file_name if file_name.exists() else Path("")
return file_name
def isPrime(number):
systemRandom = SystemRandom()
if number == 2:
return True
if number < 1 or number % 2 == 0:
return False
s = 0
d = number - 1
while d % 2 == 0:
d //= 2
s = s + 1
for _ in range(128):
x = systemRandom.randint(2, number - 1)
x = pow(x, d, number)
if x != 1 and x != number - 1:
for i in range(s):
x = pow(x, 2, number)
if x == 1:
return False
if x == number - 1:
break
if x != number - 1:
return False
return True
def getFiles(gendpointDict, uendpoint, username, upath):
label = str(uuid4())
endNames = gendpointDict.keys()
for thisEndName in endNames:
fileList = gendpointDict[thisEndName]
cryptogen = SystemRandom()
transferFile = '/tmp/transferList_' + thisEndName + '_' + str(cryptogen.randint(1,9999)) + '.txt'
file = open(transferFile, 'w')
for thisFile in fileList:
basename = os.path.basename(thisFile)
if upath[-1] != '/':
basename = '/' + basename
remote = thisFile
local = upath + basename
file.write(remote + ' ' + local + '\n')
file.close()
os.system("globus transfer "+thisEndName+" "+uendpoint+" --batch --label \"CLI Batch\" < "+transferFile)
os.remove(transferFile)
return
def generate_keys(parties_number):
""" generates a private key and saves it to a file. publishes public key to BB.
"""
private_keys = []
for party_id in range(1, parties_number + 1):
rng = SystemRandom()
private_key = rng.randint(2, VOTING_CURVE.order)
while private_key in private_keys:
private_key = rng.randint(2, VOTING_CURVE.order)
public_key = VOTING_CURVE.get_member(private_key)
data = dict(party_id=party_id, first=str(public_key.x), second=str(public_key.y))
publish_dict(data, LOCAL_BB_URL + PUBLISH_PUBLIC_KEY_TABLE_FOR_PARTIES)
filename = PRIVATE_KEYS_PATH + "privateKey_" + str(party_id) + ".txt"
f = open(filename, "w")
f.writelines(["party id: \n", str(party_id) + "\n", "private key:\n", str(private_key) + "\n"])
f.close()
def encode(openPath, writePath, data, mapSeed, password=""):
"""encode a text file with data using homoglyphs
Args:
openPath (string): path to the original text file to open
writePath (string): path to write the stego-text file
data (string): data to encode
mapSeed (string): seed to generate the lsb map
password (str, optional): password to encrypt the data with. Defaults to "".
"""
with open(openPath, encoding="utf-8") as openData:
fileData = openData.read()
position = 0
output = []
data = otp(toBin(data), password) + b"\x00"
encodeMap = getMap(fileData, mapSeed)
systemRandom = SystemRandom()
for char in data:
shift = 0
while shift < 8:
if encodeMap[position] > 0:
result, shift = encodeGlyph(fileData, position, char, shift)
else:
result, _shift = encodeGlyph(fileData, position,
systemRandom.randint(0, 1) << shift, shift)
output.append(result)
position += 1
output.append(fileData[position:])
with open(writePath, "w", encoding="utf-8") as writeData:
writeData.write("".join(output))
def create_password(length=None):
special_chars = "-.*<>_!%&/()=?@${[]}"
chars = 2 * ascii_lowercase + ascii_letters + 3 * digits + special_chars
rand = SystemRandom()
if not length:
length = rand.randint(16, 24)
return "".join(rand.choice(chars) for x in range(length))
def run(self) -> None:
# Set a random state independent for each thread
rng = SystemRandom()
seed_ = rng.randint(0, 2**32 - 1)
seed(seed_)
np.random.seed(seed_)
# Initialize Worker
print(f"Worker {self.id} Reporting for duty! seed:{seed_}")
try:
self.env = create_env(seed=seed_)
self.model_ref = ModelWrapper.wrap_model(self.backlog_queue,
self.return_dict, self.id)
self.controller = create_controller(self.model_ref)
# Run episodes until shutdown
while not self.shutdown:
print(f"Worker {self.id} Starting a new episode!")
start_time = time.time()
trajectories, stat_string = self._run_episode()
print(
f"Worker {self.id} finished an episode in {time.time() - start_time} seconds"
)
print(stat_string)
start_time = time.time()
self._add_to_buffer(trajectories)
self._update_parameters()
except Exception as e:
print(f"Worker {self.id} crashed {e}")
print(traceback.print_exception(*sys.exc_info()))
print(f"Worker {self.id} Disengaged")
def random_password(description, min_chars=10, max_chars=20):
"""
Creates a random password from uppercase letters, lowercase letters and
digits with a length between min_chars and max_chars
"""
# Open saved passwords file or create new one.
try:
fh = open("info/passwords.json", "r+")
passwords = json.load(fh)
except IOError:
fh = open("info/passwords.json", "w+")
passwords = {}
# Return password if it exists already
if description in passwords:
fh.close()
return passwords[description]
# Create new password if it does not exist
else:
seeded_random = SystemRandom()
chars = ascii_letters + digits
password_length = seeded_random.randint(min_chars, max_chars)
password = "".join(seeded_random.choice(chars) for _ in range(password_length))
passwords[description] = password
fh.seek(0)
json.dump(passwords, fh, indent=4)
fh.close()
return password
def create_dump(data, expires):
import fcntl
gen = SystemRandom()
for x in range(10):
new_id = gen.randint(1, sys.maxsize)
location = get_dump_location(new_id)
prepare_location_dirs(location)
fobj = open(location, 'a+')
try:
fcntl.lockf(fobj, fcntl.LOCK_EX)
if fobj.read():
raise OSError
except OSError:
pass
else:
save_dump(
{
'id': new_id,
'data': data,
'created': int(time.time()),
'expires': expires,
}, fobj)
print('New dump saved to %s' % location)
return new_id
finally:
fobj.close()
raise Exception('Could not generate unique ID for new dump')
def sign(self, message):
""" Signs message using ECDSA.
:param message: bytes to sign
:return: bytes representing r, s.
"""
m = hashlib.sha256()
m.update(message)
e = m.digest()
ln = self.sign_curve.order.bit_length() // 8
n = self.sign_curve.order
z = e[0:ln]
z = int.from_bytes(z, byteorder="big") # Matching the BigInteger form in the java signing.
certificate = 0
while certificate == 0:
rng = SystemRandom()
k = rng.randint(1, n)
kg = self.sign_curve.get_member(k)
r = kg.x
if r == 0:
continue
s = (mod_inv(k, n) * (z + (r * self.sign_key) % n) % n) % n
if s == 0:
continue
l = [r, s]
int_length = self.sign_curve.int_length // 8
certificate = list_to_bytes(l, int_length)
return certificate
def main(args):
r = SystemRandom()
try:
try:
_min = int(args[1])
_max = int(args[2])
except:
_min = 0
_max = int(args[1])
except:
_min = 0
_max = 10
try:
if args[0] == 'simple':
l = list(string.letters + string.digits)
r.shuffle(l)
return ''.join(l[0:_max])
if args[0] == 'strong':
l = list(string.letters + string.digits + string.punctuation)
r.shuffle(l)
return ''.join(l[0:_max])
if args[0] == 'integer':
return r.randint(_min, _max)
return r.uniform(_min, _max)
except:
return r.random()
def getFiles(gendpointDict, uendpoint, username, upath, sshkey):
cryptogen = SystemRandom()
transferFile = '/tmp/transferList' + str(cryptogen.randint(1,9999)) + '.txt'
file = open(transferFile, 'w')
label = str(uuid4())
endNames = gendpointDict.keys()
for thisEndName in endNames:
fileList = gendpointDict[thisEndName]
for thisFile in fileList:
basename = os.path.basename(thisFile)
if upath[-1] != '/':
basename = '/' + basename
remote = thisEndName + thisFile
local = uendpoint + upath + basename
file.write(remote + ' ' + local + '\n')
file.close()
os.system("cat '" + transferFile + "' | ssh " + sshkey + " " + username + "@cli.globusonline.org transfer --verify-checksum --encrypt --label=" + label + " --delete")
os.remove(transferFile)
return
def getFiles(gendpointDict, uendpoint, username, upath):
label = str(uuid4())
endNames = list(gendpointDict.keys())
for thisEndName in endNames:
fileList = gendpointDict[thisEndName]
cryptogen = SystemRandom()
transferFile = '/tmp/transferList_' + thisEndName + '_' + str(cryptogen.randint(1,9999)) + '.txt'
file = open(transferFile, 'w')
for thisFile in fileList:
basename = os.path.basename(thisFile)
if upath[-1] != '/':
basename = '/' + basename
remote = thisFile
local = upath + basename
file.write(remote + ' ' + local + '\n')
file.close()
os.system("globus transfer "+thisEndName+" "+uendpoint+" --batch --label \"CLI Batch\" < "+transferFile)
os.remove(transferFile)
return
def csprng(low, high, offset=0):
rng = SystemRandom()
rnum = rng.randint(low, high-1) + offset
if rnum < 0:
print("[-] Error: Random number generator returned out of bounds.")
return None
return rnum
class BackOffRetry(object):
def __init__(self):
self.backoff = {}
self.random = SystemRandom()
def should_run(self, instance_name):
if instance_name not in self.backoff:
self.backoff[instance_name] = {
'retries': 0,
'scheduled': time.time()
}
if self.backoff[instance_name]['scheduled'] <= time.time():
return True
return False
def do_backoff(self, instance_name):
tracker = self.backoff[instance_name]
self.backoff[instance_name]['retries'] += 1
jitter = min(
MAX_BACKOFF_SECS,
BASE_BACKOFF_SECS * 2**self.backoff[instance_name]['retries'])
# let's add some jitter (half jitter)
backoff_interval = jitter // 2
backoff_interval += self.random.randint(0, backoff_interval)
tracker['scheduled'] = time.time() + backoff_interval
return backoff_interval, self.backoff[instance_name]['retries']
def reset_backoff(self, instance_name):
self.backoff[instance_name]['retries'] = 0
self.backoff[instance_name]['scheduled'] = time.time()
def random_password(description, min_chars=10, max_chars=20):
"""
Creates a random password from uppercase letters, lowercase letters and
digits with a length between min_chars and max_chars
"""
# Open saved passwords file or create new one.
try:
fh = open('info/passwords.json', 'r+')
passwords = json.load(fh)
except IOError:
fh = open('info/passwords.json', 'w+')
passwords = {}
# Return password if it exists already
if description in passwords:
fh.close()
return passwords[description]
# Create new password if it does not exist
else:
seeded_random = SystemRandom()
chars = ascii_letters + digits
password_length = seeded_random.randint(min_chars, max_chars)
password = ''.join(
seeded_random.choice(chars) for _ in range(password_length))
passwords[description] = password
fh.seek(0)
json.dump(passwords, fh, indent=4)
fh.close()
return password
def encrypt(message,pubkey):
ordnums = [ord(ch) for ch in message]
p,a,akp = pubkey
r1 = SystemRandom(time.time())
l = r1.randint(1,p-2)
d = pow(a,l,p)
encnums = [onum * pow(akp,l,p) for onum in ordnums]
return (d,encnums)
def statsGen():
rand = SystemRandom()
while True:
stats = []
for s in range(0, 6): # Six Stats
rolls = []
for d in range(0, 4): # Four Dice
roll = rand.randint(1, 6)
if roll == 1: # Reroll 1's once
roll = rand.randint(1, 6)
rolls.append(roll)
rolls.sort()
rolls.reverse()
stats.append(rolls[0] + rolls[1] + rolls[2])
if statsCheck(stats):
return stats
return None
def checkPrime(n,k=10):
isComposite = False
for i in range(0,k):
r1 = SystemRandom(time.time())
a = r1.randint(1,n-1)
isComposite = pow(a,n-1,n) != 1
if isComposite:
return False
return True
def key_gen():
"""
Generates a random key for bets, placed bets and accounts.
:return: Random key between 0 and 2147483647 (max size for django's PositiveIntegerField)
"""
from random import SystemRandom
randomiser = SystemRandom()
return randomiser.randint(0, 2147483647)
def generatePin(cls):
"""
Generate a pin to be entered into another device.
Restricting this to 8 bytes (16 hex chars) for now.
"""
pin = bytearray(8)
random = SystemRandom()
for i in range(8):
pin[i] = random.randint(0,0xff)
return str(pin).encode('hex')
class MultiElGamal(object):
def __init__(self, p, g):
self.p = p
self.q = (p-1)/2
self.g = g
self.random_source = SystemRandom()
def generate_private_key(self):
return self.random_source.randint(2, self.q - 1)
def generate_public_key(self, x):
return pow(self.g, x, self.p)
def generate_shares(self, x, share_count, recovery_threshold):
# generate a list of coefficients, of length recovery_threshold, in the form:
# [x, randint(0, q - 1), randint(0, q - 1) ...]
coefficients = [x] + [self.random_source.randint(0, self.q - 1) for _ in range(recovery_threshold - 1)]
# use the coefficients to construct a polynomial, of degree recovery_threshold - 1,
# with y-intercept of x, in the form:
# coefficients[0] * i ^ 0 + coefficients[1] * i ^ 1 + coefficients[2] * i ^ 2 ...
def recovery_polynomial(i):
return sum(coefficient * pow(i, j) for j, coefficient in enumerate(coefficients))
# generate shares, in the form:
# [recovery_polynomial(1), recovery_polynomial(2), ..., recovery_polynomial(share_count)]
shares = [recovery_polynomial(i+1) for i in range(share_count)]
# generate commitments for each random coefficient, in the form:
# [g ^ coefficients[1] % p, g ^ coefficients[2] % p ...]
commitments = [pow(self.g, coefficient, self.p) for coefficient in coefficients[1:]]
return shares, commitments, coefficients
def confirm_share(self, share_input, share_output, commitments):
secret_share_check = pow(self.g, share_output, self.p)
commitment_check = modular_product(
(pow(commitment, pow(share_input, i), self.p) for i, commitment in
enumerate(commitments)), self.p)
return secret_share_check == commitment_check
def combine_public_keys(self, y_list):
return modular_product([y for y in y_list], self.p)
def make_board():
global ship_coord, board_size
# The board size is 5 times the number of ships
board_size = num_ships * 5
# Build an empty board of ocean waves
for y in range(board_size):
board.append(["~"] * board_size)
for z in range(num_ships):
ship_row = SystemRandom.randint(r1, 1, board_size)
ship_col = SystemRandom.randint(r1, 1, board_size)
# For every ship we roll to see if it is longer than one coordinate
ship_length = SystemRandom.randint(r1, 0, 4)
# If it is, then we roll to see what direction it stems out from.
if ship_length:
ship_orientation = SystemRandom.randint(r1, 1, 4)
# These are ships that can be 2-5 coordinates long and stem in one of the 4 directions.
# We also don't worry if they leave the board, it just makes a shorter ship.
if ship_orientation == 1:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_row += 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 2:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_col += 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 3:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_row -= 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 4:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_col -= 1
ship_coord.append([ship_row, ship_col])
# This is a single coordinate ship
else:
ship_coord.append([ship_row, ship_col])
class CameraService(Service):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._rnd = SystemRandom()
@rpc_method
async def take_photo(self):
return 'Picture `{}` has been taken.'.format(await self.save_photo())
async def save_photo(self):
await asyncio.sleep(self._rnd.randint(500, 1000) / 1000)
return '{}.bmp'.format(uuid4().hex)
def roll(self, count):
result = []
while count:
count -= 1
random = SystemRandom()
result.append(random.randint(1,6))
# superfluous here, but handy if you switch
# to quantum results
result = [int(x) for x in result]
return result
def create_salt() -> bytes:
"""
Create a Salt in Bytes
:return: Salt data
:rtype: bytes
"""
rand = SystemRandom()
salt_bytes = []
while len(salt_bytes) < 64:
salt_bytes.append(rand.randint(0, 255))
return bytes(salt_bytes)
def simexp(nvars): nvar1 = nvars[0] nvar2 = nvars[1] r = SystemRandom() npr.seed(r.randint(0,1e15)) x = npr.exponential(30, nvar1) npr.seed(r.randint(0,1e15)) y = npr.exponential(35,nvar2) if False: x.sort() y.sort() darray = np.zeros(100) for i in xrange(0,100): yprime = r.sample(y, len(x)) yprime.sort() darray[i] = util.dice(x,yprime) return max_conf_est(darray, 0.99) return new_similarity_invcdf(x,y)
def place_ships():
global ship_coord
for z in range(num_ships):
ship_row = SystemRandom.randint(r1, 1, board_size)
ship_col = SystemRandom.randint(r1, 1, board_size)
# For every ship we roll to see if it is longer than one coordinate
ship_length = SystemRandom.randint(r1, 0, 4)
# If it is, then we roll to see what direction it stems out from.
if ship_length:
ship_orientation = SystemRandom.randint(r1, 1, 4)
# These are ships that can be 2-5 coord long and stem in one of the 4 directions.
# We also don't worry if they leave the board, this is caught later and we can't fire off the board
if ship_orientation == 1:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_row += 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 2:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_col += 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 3:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_row -= 1
ship_coord.append([ship_row, ship_col])
elif ship_orientation == 4:
ship_coord.append([ship_row, ship_col])
for i in range(1, ship_length):
ship_col -= 1
ship_coord.append([ship_row, ship_col])
# This saves the coordinates to be referenced for hits later
# This is a single coordinate ship
else:
ship_coord.append([ship_row, ship_col])
def from_int(num, num_len, curve):
"""encodes integer num to an ECCGroupMember object
algorithm from https://eprint.iacr.org/2013/373.pdf part 2.4
num must be of bit size at most half of the bit size of curve.order"""
rng = SystemRandom()
prefix_length = curve.order.bit_length() - num_len
a = curve.a
b = curve.b
p = curve.p
while True:
prefix = rng.randint(1, 2 ** prefix_length - 1)
candidate_x = concat_bits(prefix, num, num_len)
candidate_y2 = (candidate_x ** 3 + a * candidate_x + b) % p
candidate_y = mod_sqrt(candidate_y2, p)
if ECGroupMember.verify_point(candidate_x, candidate_y, curve):
return ECGroupMember(curve, candidate_x, candidate_y)
def __init__(self, conf=None):
if not conf:
conf = Configuration()
self._conf = conf
self.encoding = conf.get('encoding') or 'utf-8'
self._iter = conf.get('iter') or 0.05
self._timeout = conf.get('timeout') or 60
if not(1 <= self._timeout <= 60):
self._timeout = 60
self._buffer_size = conf.get('buffer_size') or 512
self._logger = conf.get_logger(
wraper=LoggerWrapper('client'))
self.command_builder = self.cls_command_builder()
rand = SystemRandom()
self._cid_part = '{:0>4}'.format(hex(rand.randint(0, int('ffff', 16)))[2:])
def prepare_auth_token(conf, silently=False):
assert isinstance(conf, Configuration)
priv_key_path = conf.get('crypto_priv_key_path')
rand = SystemRandom()
logger = conf.get_logger()
auth_data = None
try:
with open(priv_key_path, 'r') as key_file:
priv_rsakey = key_file.read()
algorithms = get_default_algorithms()
# 2 random parts
segments = [
base64.urlsafe_b64encode(''.join(
# get ascii from [48, 122]
chr(rand.randint(48, 123))
for _ in range(_random_part_size)
).encode(encoding=encoding))
for _ in range(2)
]
algorithm = conf.get('crypto_algorithm')
try:
alg_obj = algorithms[algorithm]
signature = alg_obj.sign(
b'.'.join(segments),
alg_obj.prepare_key(priv_rsakey))
segments.append(base64.urlsafe_b64encode(signature))
auth_data = b'.'.join(segments)
except KeyError:
if not silently:
raise NotImplementedError(
'Algorithm "{}" not supported.'.format(algorithm))
except (TypeError, FileNotFoundError, PermissionError) as err:
logger.fatal(
'Can not use private key "{}", error: {}'.format(
priv_key_path, err))
if not silently:
raise
else:
logger.debug('auth data: {}'.format(auth_data))
return auth_data
def chancesuccess():
form = RandNumForm()
if form.validate_on_submit():
rngchance = form.rngchance.data
rngcount = form.rngcount.data
if rngchance not in [str(x) for x in range(0, 101)]:
rngerror = "Chance must be whole number from 0 to 100."
return render_template('chancesuccess.html', form=form,
rngerror=rngerror)
if rngcount not in [str(x) for x in range(1, 101)]:
rngerror = "Count must be whole number from 1 to 100."
return render_template('chancesuccess.html', form=form,
rngerror=rngerror)
randrng = SystemRandom()
successcount = sum([1 for x in range(int(rngcount)) if int(rngchance) >= randrng.randint(1, 100)])
results = (successcount, rngcount)
return render_template('chancesuccess.html', form=form, results=results)
return render_template('chancesuccess.html', form=form)
