def form_req(seq):
i = {}
keyword = {
'createorderwithmobile': 'seat',
'createorder': 'seat',
}
for key in seq[1]:
if isinstance(key, str):
if key in data_dic:
i.update({key: data_dic[key]})
else:
raise WrongData
else:
available = data_dic.get('available_seat')
not_available = data_dic.get('not_available_seat')
clear(available)
clear(not_available)
try:
i.update({
keyword[seq[0]]:
str(
random.sample(available, key["seat"][0]) +
random.sample(not_available, key["seat"][1])).replace(
" ", "")
})
except:
raise WrongData
i.update(seq[2])
reform = [seq[0], i, seq[3]]
return reform
def test_hash_int_list(self):
for i in range(1000):
ls1 = sample(population=range(100, 999999999999), k=6)
ls2 = sample(population=range(100, 999999999999), k=6)
while ls1 == ls2:
ls2 = sample(population=range(100, 999999999999), k=6)
ds3 = hash_int(ls1)
ds4 = hash_int(ls2)
ds3c = hash_int(ls1)
ds4c = hash_int(ls2)
assert ds3 == ds3c
assert ds4 == ds4c
assert ds3 != ds4
def initialize_vault(self, mp):
vd = VaultDistribution()
if not os.path.exists(self.vault_fl):
buf = rnd_source.read(hny_config.HONEY_VAULT_ENCODING_SIZE * 4)
t_s = struct.unpack('!%sI' % hny_config.HONEY_VAULT_ENCODING_SIZE,
buf)
self.H = t_s[:hny_config.HONEY_VAULT_GRAMMAR_SIZE]
t_s = t_s[hny_config.HONEY_VAULT_GRAMMAR_SIZE:]
self.S = [
t_s[i * hny_config.PASSWORD_LENGTH:(i + 1) *
hny_config.PASSWORD_LENGTH] for i in range(self.s)
]
#buf = struct.unpack('!%sI' % self.mpass_set_size, rnd_source.read(self.mpass_set_size))
# self.machine_pass_set = \
# list(''.join(["{0:08b}".format(x)
# for x in struct.unpack(
# "%sB" % self.mpass_set_size, buf)]))
# assert len(self.machine_pass_set) >= len(self.S)
self.machine_pass_set = list('0' * (self.mpass_set_size * 8))
k = int(math.ceil(hny_config.HONEY_VAULT_STORAGE_SIZE * \
hny_config.MACHINE_GENRATED_PASS_PROB/1000.0))
for i in random.sample(range(hny_config.HONEY_VAULT_STORAGE_SIZE),
k):
self.machine_pass_set[i] = '1'
self.salt = rnd_source.read(8)
self.save(mp)
else:
self.load(mp)
def pickDiffBlocks(numOfBlocks, common, totalBlocks): numDiff = numOfBlocks - len(common) blocks = range(totalBlocks) for block_index in xrange(numOfBlocks): if block_index in common: blocks.remove(block_index) a_diff = random.sample(blocks, numDiff) for block_index in a_diff: blocks.remove(block_index) b_diff = random.sample(blocks, numDiff) return (a_diff, b_diff)
def __init__(self, sender, receiver, data, *, part=1, count=1,
pkgkey=None):
"""
Instantiates a new object. This should not be invoked directly, use
pack instead.
@param sender: id of the sending client
@type sender: int
@param receiver: id of the receiving client
@type receiver: int
@param data: data of the PluginCommand
@type data: str
@param part: number of the splitted package, defaults to 1
@type part: int
@param count: count of splitted packages, defaults to 1
@type count: int
@param pkgkey: key of the package, defaults to None, then a random key
is generated
@type pkgkey: str
"""
super().__init__()
if pkgkey:
self.pkgkey = pkgkey
else:
self.pkgkey = "".join(random.sample(PKGKEY_ALPHABET, 4))
self.sender = sender
self.receiver = receiver
self.data = data
self.part = part
self.count = count
def pad_pkcs1(self, msg, btype=1):
npad = self.k - 3 - len(msg)
if btype == 1:
padding = npad * b'\xff'
elif btype == 2:
padding = bytes(random.sample(range(1, 256), npad))
return b'\x00' + bytes([btype]) + padding + b'\x00' + msg
def initialize_vault(self, mp):
vd = VaultDistribution()
if not os.path.exists(self.vault_fl):
buf = rnd_source.read(hny_config.HONEY_VAULT_ENCODING_SIZE * 4)
t_s = struct.unpack(
'!%sI' % hny_config.HONEY_VAULT_ENCODING_SIZE, buf)
self.H = t_s[:hny_config.HONEY_VAULT_GRAMMAR_SIZE]
t_s = t_s[hny_config.HONEY_VAULT_GRAMMAR_SIZE:]
self.S = [t_s[i*hny_config.PASSWORD_LENGTH:(i+1)*hny_config.PASSWORD_LENGTH]
for i in range(self.s)]
#buf = struct.unpack('!%sI' % self.mpass_set_size, rnd_source.read(self.mpass_set_size))
# self.machine_pass_set = \
# list(''.join(["{0:08b}".format(x)
# for x in struct.unpack(
# "%sB" % self.mpass_set_size, buf)]))
# assert len(self.machine_pass_set) >= len(self.S)
self.machine_pass_set = list('0'*(self.mpass_set_size*8))
k = int(math.ceil(hny_config.HONEY_VAULT_STORAGE_SIZE * \
hny_config.MACHINE_GENRATED_PASS_PROB/1000.0))
for i in random.sample(range(hny_config.HONEY_VAULT_STORAGE_SIZE), k):
self.machine_pass_set[i] = '1'
self.salt = rnd_source.read(8)
self.save(mp)
else:
self.load(mp)
def parameterizable_re_encryption_process_test(self, new_t: int, new_n: int):
new_tp = ThresholdParameters(new_t, new_n)
new_pk, new_shares = central.create_public_key_and_shares_centralized(self.cp, new_tp)
assert new_pk != self.pk, "Public keys for new and old access structure are the same"
# Without loss of generality we assume the lists to be ordered in a way, that remaining participants
# are placed at the beginning of the list.
# Choose t_max shares randomly from first min_n old and new shares as the shares of one distinct participant.
max_t = max(self.tp.t, new_tp.t)
min_n = min(self.tp.n, new_tp.n)
t_old_shares = random.sample(self.shares[:min_n], k=max_t)
t_old_shares_x = [share.x for share in t_old_shares]
t_new_shares = random.sample(new_shares[:min_n], k=max_t)
t_new_shares_x = [share.x for share in t_new_shares]
partial_re_encrypt_keys = []
for i, (s_old, s_new) in enumerate(zip(t_old_shares, t_new_shares)):
old_lambda = central.lagrange_coefficient_for_key_share_indices(t_old_shares_x, t_old_shares_x[i], self.cp)
new_lambda = central.lagrange_coefficient_for_key_share_indices(t_new_shares_x, t_new_shares_x[i], self.cp)
partial_key = participant.compute_partial_re_encryption_key(s_old, old_lambda, s_new, new_lambda)
partial_re_encrypt_keys.append(partial_key)
re_encrypt_key = central.combine_partial_re_encryption_keys(partial_re_encrypt_keys,
self.pk,
new_pk,
self.tp,
new_tp)
re_em = central.re_encrypt_message(self.em, re_encrypt_key)
self.assertNotEqual(self.em, re_em)
# successful decryption with t shares
new_reconstruct_shares = random.sample(new_shares, new_tp.t)
new_partial_decryptions = [participant.compute_partial_decryption(re_em, share) for share in new_reconstruct_shares]
decrypted_message = central.decrypt_message(new_partial_decryptions, re_em, new_tp)
self.assertEqual(self.message, decrypted_message)
# failing decryption with t - 1 shares
with self.assertRaises(ThresholdCryptoError) as dec_exception_context:
less_reconstruct_shares = random.sample(new_shares, new_tp.t - 1)
new_partial_decryptions = [participant.compute_partial_decryption(re_em, share) for share in less_reconstruct_shares]
central._decrypt_message(new_partial_decryptions, re_em)
self.assertIn("Message decryption failed", str(dec_exception_context.exception))
def __init__(self, network, net_id, vendors):
Node.__init__(self, network, net_id)
self.vendors = vendors
self.valid_scripsIDs = sample(range(0, 0xFFFFFFFF), 1000)
self.used_scripsIDs = []
self.master_scrips = [] # length of ten
self.master_customers = [] # length of ten
def query():
p, q = random.sample(primes, 2)
n = p * q
e = 65537
key = RSA.construct((n, e))
cipher = PKCS1_OAEP.new(key)
enc = cipher.encrypt(flag)
return key, enc
def genKey(self):
"generate a random key"
n = self.keySizeSB.value()
char = string.printable.rstrip() #map(chr, range(256))
while len(char) < n:
char += char
key = ''.join(random.sample(char, n))
self.keyInput.setText(key)
def generate_phrase_str(phrase, separator=DEFAULTS['separator']):
phrase_str = ''
while phrase:
if len(phrase) == 1:
phrase_str = phrase_str + phrase.pop(0)
else:
sep = sample(separator, 1)[0]
phrase_str = phrase_str + phrase.pop(0) + sep
return phrase_str
def generate_aes_key():
"""
Generate a random new 128-bit AES key using Pycrypto's secure Random functions.
"""
punctuation = '!#$%&()*+,-./:;<=>?@[\]^_`{|}~'
return ''.join(
random.sample(
string.ascii_letters + string.digits +
'!#$%&()*+,-./:;<=>?@[\]^_`{|}~', 32))
def certifying_client_key(self):
TOKEN_CHAR_LIST = "abcdefghij!@#$%"
passphrase = ''.join(random.sample(TOKEN_CHAR_LIST, 10))
shared_key = hasher(passphrase)
CertifiedKey = hasher(str(self.PUBLIC_KEY))
print(" hash of your Key : " + str(CertifiedKey))
if CertifiedKey:
return (CertifiedKey)
else:
logging.log("Unable to certify key.", msg_type='ERROR')
def getSharedKey(self):
TOKEN_CHAR_LIST = "abcdefghij!@#$%"
passphrase = ''.join(random.sample(TOKEN_CHAR_LIST, 10))
shared_key = hasher(passphrase)
print("shared_key" + str(shared_key) + str(type(shared_key)))
print("custemor_pub_key : " + str(self.custemor_pub_key) + str(type(self.custemor_pub_key)))
EnSharedKey = RSA_.encrypt(self.custemor_pub_key, shared_key)
if EnSharedKey:
return (shared_key, EnSharedKey)
else:
logging.log("Unable to encrypt shared key with RSA.", msg_type='ERROR')
def generate_example(self):
while True:
example = "".join(sample(self.example_words, self.min_num_words))
try:
self.validate(example)
break
except ValidationError:
pass
return example
def pack(cls, sender, receiver):
"""
Creates a new keyrequest
@param sender: the id of the sending client
@type sender: int
@param receiver: the id of the target client
@type receiver: int
@return: the created keyrequest command
@rtype: _RequestKey
"""
return _RequestKey(sender, receiver,
"".join(random.sample(PKGKEY_ALPHABET, 4)))
def getSharedKey(self):
TOKEN_CHAR_LIST = "abcdefghij!@#$%"
# Generate unique symmetric 10bit key for each client
passphrase = ''.join(random.sample(TOKEN_CHAR_LIST, 10))
shared_key = hasher(passphrase)
EnSharedKey = RSA_.encrypt(self.PUBLIC_KEY, shared_key)
if EnSharedKey:
return (shared_key, EnSharedKey)
else:
logging.log("Unable to encrypt shared key with RSA.",
msg_type='ERROR')
def encryptToken(self, token):
"""
Encrypts token, returning:
(token_crypt, crypt_iv, crypt_key)
where:
token_crypt : encrypted token
crypt_iv : the initialization vector used for encryption
crypt_key : the encryption key used for encryption
"""
if token is None:
logger.error("AbstractServer.saveToken() :: ERROR, token is None; aborting...")
raise ValueError("ERROR, token is None")
crypt_key_default = '6xytURQ4JITKMhgN'
crypt_key = self.Confighandler.get('crypt_key', '6xytURQ4JITKMhgN') # crypt key should generally be stored in the system config; different from the one where crypt_iv is stored...
# Note: I'm pretty sure the initiation vector needs to be randomly generated on each encryption,
# but not sure how to do this in practice... should the IV be saved for later decryption?
# Probably only relevant for multi-message encrypted communication and not my simple use-case...?
# crypt_iv = self.Confighandler.get('crypt_key', 'Ol6beVHM91ZBh7XP')
# ok, edit: I'm generating a random IV on every new save; this can be "publically" readable...
# But, it probably does not make a difference either way; the crypt_key is readable anyways...
if crypt_key == crypt_key_default:
new_crypt_key = "".join(crypt_random.sample(string.ascii_letters+string.digits, 16))
if 'system' in self.Confighandler.Configs:
self.Confighandler.setkey('crypt_key', new_crypt_key, 'system', autosave=True)
crypt_key = new_crypt_key
logger.info("System encryption key set to new random string of length %s", len(new_crypt_key))
else:
logger.info("Using default crypt_key for encryption. You should create a 'system' config file, \
optionally using labfluence --createconfig system.")
else:
logger.debug("Using crypt_key from confighandler...")
crypt_iv = "".join(crypt_random.sample(string.ascii_letters+string.digits, 16))
# Not exactly 128-bit worth of bytes since ascii_letters+digits is only 62 in length, but should be ok still; I want to make sure it is realiably persistable with yaml.
cryptor = AES.new(crypt_key, AES.MODE_CFB, crypt_iv)
token_crypt = cryptor.encrypt(token)
logger.debug("Token successfully encrypted (using newly generated crypt iv)")
return (token_crypt, crypt_iv, crypt_key)
def gen_nonce_list(total, landmark_num):
""" generate random indexes for all landmarks in a big list,
and return it. Other code should slice the big list for
each landmark in the following steps.
total -- total number of tags
landmark_num -- total number of landmarks
"""
if total > 10000:
n = total / 2000
elif total > 1000:
n = total / 200
elif total > 100:
n = max(landmark_num, total / 20)
else:
n = landmark_num
return random.sample(range(total), n)
def create_new_user_id(session):
"""
Create a new random user name by randomly sampling from a list of lowercase
and uppercase letters and numbers in equal proportions using PyCrypto.
A new user name will be unique and will not already exist in the DB.
Args:
session (sqlalchemy.session.Session): DB session
Returns:
str: Randomly generated user name that does not exist in the DB.
"""
while True:
new_user_name = ''.join(random.sample(LETTERS_NUMBERS_RANDOM_SAMPLING_SET, USER_NAME_LENGTH))
if session.query(User).filter(User.name == new_user_name).count() == 0:
return new_user_name
def interleave_messages(encrypted_and_fragmented_messages, size_constraint):
size_constraint = _add_chaff(encrypted_and_fragmented_messages,
size_constraint)
#-------------------------------------------------------------------------------
# this is done in an annoying way...
messages = encrypted_and_fragmented_messages.values()
# Get the indices of which message goes where:
msg_idx = [
msg_i for msg_i, frags in enumerate(messages)
for _, frag in enumerate(frags)
]
permuted_msg_idx = random.sample(msg_idx, len(msg_idx))
permuted = reversed([messages[i].pop() for i in permuted_msg_idx])
return reduce(lambda x, y: x + y, permuted)
def mkpass (self, entropy=None):
if self.mode == 'external':
return subprocess.check_output (self.call,shell=True)
entropy=self.bits if not entropy else int(entropy)
if self.mode in ['x','xkcd']:
with open (self.dict) as f: lut = list(set(f.read().replace("'s",'').split()))
lutsz = len (lut)
return ' '.join (random.sample(lut,self.entropy_estimate(entropy,lutsz)))
else:
if self.mode in ['p','print']:
lut = string.ascii_letters+string.digits+string.punctuation
elif self.mode in ['a','alnum']:
lut = string.ascii_letters+string.digits
lutsz = len (lut)
bytes_needed = self.entropy_estimate (entropy, lutsz)
return ''.join (map (lambda x: lut[x%lutsz], bytearray(self.rng.read(bytes_needed))))
def generate_password(length, allowed_chars=None, required_ranges=None):
if not allowed_chars:
allowed_chars = string.letters+string.digits
# generate password
password = [choice(allowed_chars) for _ in range(length)]
# if certain ranges of characters are required (e.g A-Z), make sure they're each in the password
if required_ranges:
# find a target character in the password to hold a letter from each required range
indexes = sample(range(len(password)), len(required_ranges))
# put a letter from each required range in the selected location
for index, required_range in zip(indexes, required_ranges):
if required_range in named_ranges:
required_range = named_ranges[required_range]
password[index] = choice(required_range)
return ''.join(password)
def cryptString(secret, plain):
'''只有CM在使用，以后不要再使用'''
obj = Blowfish.new(secret, Blowfish.MODE_ECB)
randstring = str.join(
'', random.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890', 12))
split = random.randrange(10) + 1
s = randstring[:split] + ':valid:' + plain + ':valid:' + randstring[split:]
length = len(s)
l = length + 8 - (length % 8)
padded = s + " " * (8 - length % 8)
ciph = obj.encrypt(padded[:l])
try:
return b32encode(ciph)
except NameError:
return encodestring(ciph)
def gen_masterpwd(length=128, public=None):
""" Generates a random masterkey password and optionaly encrypt it
Keywords arguments:
length -- The length of the masterkey password we want (default 128)
public -- The public key file to use to encrypt the masterkey password (default None)
"""
items = string.printable.replace(' ', '')
master = []
for i in range(length):
master.append(items[rand.randrange(0, len(items))])
symbols = "".join(rand.sample(string.punctuation, 2))
master.append(symbols)
master = "".join(master)
if public is not None:
try:
pub_file = open(public, 'r')
except Exception as err:
log.error("[gen_masterpwd] {}".format(err))
else:
pub_key = pub_file.read()
rsa_key = rsa.importKey(pub_key)
cipher = pkcs.new(rsa_key)
try:
ciph = cipher.encrypt(master.encode('utf-8'))
except Exception as err:
log.error(
"[gen_masterpwd] Error while encrypting the master password : {}"
.format(err))
else:
return base64.b64encode(ciph)
finally:
pub_file.close()
else:
return master
def cryptString(secret, plain):
'''只有CM在使用，以后不要再使用'''
obj = Blowfish.new(secret, Blowfish.MODE_ECB)
randstring = str.join(
'',
random.sample(
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890',
12))
split = random.randrange(10) + 1
s = randstring[:split] + ':valid:' + plain + ':valid:' + randstring[split:]
length = len(s)
l = length + 8 - (length % 8)
padded = s + " " * (8 - length % 8)
ciph = obj.encrypt(padded[:l])
try:
return b32encode(ciph)
except NameError:
return encodestring(ciph)
def gen_masterpwd(length=128, public=None):
""" Generates a random masterkey password and optionaly encrypt it
Keywords arguments:
length -- The length of the masterkey password we want (default 128)
public -- The public key file to use to encrypt the masterkey password (default None)
"""
items = string.printable.replace(' ', '')
master = []
for i in range(length):
master.append(items[rand.randrange(0, len(items))])
symbols = "".join(rand.sample(string.punctuation, 2))
master.append(symbols)
master = "".join(master)
if public is not None:
try:
pub_file = open(public, 'r')
except Exception as err:
log.error("[gen_masterpwd] {}".format(err))
else:
pub_key = pub_file.read()
rsa_key = rsa.importKey(pub_key)
cipher = pkcs.new(rsa_key)
try:
ciph = cipher.encrypt(master.encode('utf-8'))
except Exception as err:
log.error("[gen_masterpwd] Error while encrypting the master password : {}".format(err))
else:
return base64.b64encode(ciph)
finally:
pub_file.close()
else:
return master
def pack(cls, sender, receiver, data):
"""
Packs some string data to one or more PluginCommands
@param sender: the own client id
@type sender: int
@param receiver: id of the target client
@type receiver: int
@param data: data to send
@type data: str
@return: a list of plugincommands
@rtype: list(_GenericPluginCommand)
"""
pkgcount = math.ceil(len(data) / MAX_CMD_SIZE)
key = "".join(random.sample(PKGKEY_ALPHABET, 4))
pkgs = []
for i in range(pkgcount):
pkgs.append(cls(sender, receiver,
data[i * MAX_CMD_SIZE:(i + 1) * MAX_CMD_SIZE],
part=i + 1, count=pkgcount, pkgkey=key))
return pkgs
def generate_password(self):
# select password length between min_length and max_length, with preference for PASSWORD_LENGTH
length = max(
min(PASSWORD_LENGTH,
self.password_rules.get('max_length', PASSWORD_LENGTH)),
self.password_rules.get('min_length', 0))
# generate password from allowed_chars or PASSWORD_CHARS
chars = self.password_rules.get('allowed_chars', PASSWORD_CHARS)
password = ''.join(choice(chars) for _ in range(length))
# if certain ranges of characters are required (e.g A-Z), make sure they're each in the password
required_ranges = self.password_rules.get('required_ranges', [])
if required_ranges:
# find a target character in the password to hold a letter from each required range
indexes = sample(range(len(password)), len(required_ranges))
# put a letter from each required range in the selected location
for index, required_range in zip(indexes, required_ranges):
password[index] = choice(required_range)
return password
def generate_password(self):
# select password length between min_length and max_length, with preference for PASSWORD_LENGTH
length = max(
min(
PASSWORD_LENGTH,
self.password_rules.get('max_length', PASSWORD_LENGTH)
), self.password_rules.get('min_length', 0))
# generate password from allowed_chars or PASSWORD_CHARS
chars = self.password_rules.get('allowed_chars', PASSWORD_CHARS)
password = ''.join(choice(chars) for _ in range(length))
# if certain ranges of characters are required (e.g A-Z), make sure they're each in the password
required_ranges = self.password_rules.get('required_ranges', [])
if required_ranges:
# find a target character in the password to hold a letter from each required range
indexes = sample(range(len(password)), len(required_ranges))
# put a letter from each required range in the selected location
for index, required_range in zip(indexes, required_ranges):
password[index] = choice(required_range)
return password
def mkpass(self, entropy=None):
if self.mode == 'external':
return subprocess.check_output(self.call, shell=True)
entropy = self.bits if not entropy else int(entropy)
if self.mode in ['x', 'xkcd']:
with open(self.dict) as f:
lut = list(set(f.read().replace("'s", '').split()))
lutsz = len(lut)
return ' '.join(
random.sample(lut, self.entropy_estimate(entropy, lutsz)))
else:
if self.mode in ['p', 'print']:
lut = string.ascii_letters + string.digits + string.punctuation
elif self.mode in ['a', 'alnum']:
lut = string.ascii_letters + string.digits
elif self.mode in ['n', 'numeric']:
lut = string.digits
lutsz = len(lut)
bytes_needed = self.entropy_estimate(entropy, lutsz)
return ''.join(
map(lambda x: lut[x % lutsz],
bytearray(self.rng.read(bytes_needed))))
def generate_passphrase(words=DEFAULTS["words"],
length=DEFAULTS["length"],
separator=DEFAULTS['separator'],
addnum=False,
caps=False):
phrase = []
for _ in range(words):
word = sample(WORD_LIST, 1)[0]
if caps:
if randint(0,1):
phrase.append(word.upper())
else:
phrase.append(word)
else:
phrase.append(word)
if addnum:
num = str(randint(0, 9999)).rjust(4, '0')
phrase.insert(randint(0,len(phrase)),num)
phrase_str = generate_phrase_str(phrase, separator)
if len(phrase_str) >= length:
return phrase_str
else:
generate_passphrase(words, length, separator, addnum, caps)
def runTest(self):
"""Crypto.Random.new()"""
# Import the Random module and try to use it
from Crypto import Random
randobj = Random.new()
x = randobj.read(16)
y = randobj.read(16)
self.assertNotEqual(x, y)
z = Random.get_random_bytes(16)
self.assertNotEqual(x, z)
self.assertNotEqual(y, z)
# Test the Random.random module, which
# implements a subset of Python's random API
# Not implemented:
# seed(), getstate(), setstate(), jumpahead()
# random(), uniform(), triangular(), betavariate()
# expovariate(), gammavariate(), gauss(),
# longnormvariate(), normalvariate(),
# vonmisesvariate(), paretovariate()
# weibullvariate()
# WichmannHill(), whseed(), SystemRandom()
from Crypto.Random import random
x = random.getrandbits(16*8)
y = random.getrandbits(16*8)
self.assertNotEqual(x, y)
# Test randrange
if x>y:
start = y
stop = x
else:
start = x
stop = y
for step in range(1,10):
x = random.randrange(start,stop,step)
y = random.randrange(start,stop,step)
self.assertNotEqual(x, y)
self.assertEqual(start <= x < stop, True)
self.assertEqual(start <= y < stop, True)
self.assertEqual((x - start) % step, 0)
self.assertEqual((y - start) % step, 0)
for i in range(10):
self.assertEqual(random.randrange(1,2), 1)
self.assertRaises(ValueError, random.randrange, start, start)
self.assertRaises(ValueError, random.randrange, stop, start, step)
self.assertRaises(TypeError, random.randrange, start, stop, step, step)
self.assertRaises(TypeError, random.randrange, start, stop, "1")
self.assertRaises(TypeError, random.randrange, "1", stop, step)
self.assertRaises(TypeError, random.randrange, 1, "2", step)
self.assertRaises(ValueError, random.randrange, start, stop, 0)
# Test randint
x = random.randint(start,stop)
y = random.randint(start,stop)
self.assertNotEqual(x, y)
self.assertEqual(start <= x <= stop, True)
self.assertEqual(start <= y <= stop, True)
for i in range(10):
self.assertEqual(random.randint(1,1), 1)
self.assertRaises(ValueError, random.randint, stop, start)
self.assertRaises(TypeError, random.randint, start, stop, step)
self.assertRaises(TypeError, random.randint, "1", stop)
self.assertRaises(TypeError, random.randint, 1, "2")
# Test choice
seq = list(range(10000))
x = random.choice(seq)
y = random.choice(seq)
self.assertNotEqual(x, y)
self.assertEqual(x in seq, True)
self.assertEqual(y in seq, True)
for i in range(10):
self.assertEqual(random.choice((1,2,3)) in (1,2,3), True)
self.assertEqual(random.choice([1,2,3]) in [1,2,3], True)
if sys.version_info[0] is 3:
self.assertEqual(random.choice(bytearray(b('123'))) in bytearray(b('123')), True)
self.assertEqual(1, random.choice([1]))
self.assertRaises(IndexError, random.choice, [])
self.assertRaises(TypeError, random.choice, 1)
# Test shuffle. Lacks random parameter to specify function.
# Make copies of seq
seq = list(range(500))
x = list(seq)
y = list(seq)
random.shuffle(x)
random.shuffle(y)
self.assertNotEqual(x, y)
self.assertEqual(len(seq), len(x))
self.assertEqual(len(seq), len(y))
for i in range(len(seq)):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
self.assertEqual(seq[i] in x, True)
self.assertEqual(seq[i] in y, True)
z = [1]
random.shuffle(z)
self.assertEqual(z, [1])
if sys.version_info[0] == 3:
z = bytearray(b('12'))
random.shuffle(z)
self.assertEqual(b('1') in z, True)
self.assertRaises(TypeError, random.shuffle, b('12'))
self.assertRaises(TypeError, random.shuffle, 1)
self.assertRaises(TypeError, random.shuffle, "1")
self.assertRaises(TypeError, random.shuffle, (1,2))
# 2to3 wraps a list() around it, alas - but I want to shoot
# myself in the foot here! :D
# if sys.version_info[0] == 3:
# self.assertRaises(TypeError, random.shuffle, range(3))
# Test sample
x = random.sample(seq, 20)
y = random.sample(seq, 20)
self.assertNotEqual(x, y)
for i in range(20):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
z = random.sample([1], 1)
self.assertEqual(z, [1])
z = random.sample((1,2,3), 1)
self.assertEqual(z[0] in (1,2,3), True)
z = random.sample("123", 1)
self.assertEqual(z[0] in "123", True)
z = random.sample(list(range(3)), 1)
self.assertEqual(z[0] in range(3), True)
if sys.version_info[0] == 3:
z = random.sample(b("123"), 1)
self.assertEqual(z[0] in b("123"), True)
z = random.sample(bytearray(b("123")), 1)
self.assertEqual(z[0] in bytearray(b("123")), True)
self.assertRaises(TypeError, random.sample, 1)
from Crypto.Random import random # This is supposed to be a cryptographically strong version of Python's standard "random" module
import os, sys, argparse
from clint import textui
parser = argparse.ArgumentParser()
parser.add_argument( '-keylen', type=int, action="store", required=True )
parser.add_argument( '-numkeys', type=int, nargs=1, required=True )
parser.add_argument( '-characterset', action="store", required=True )
args = parser.parse_args()
if os.path.exists( args.characterset ):
args.characterset = open( args.characterset, "r" ).read().strip()
sys.stderr.write( "The key space has a total of {0} keys".format( pow( len( args.characterset ), args.keylen ) ) )
keylen = args.keylen
for i in textui.progress.bar( xrange( args.numkeys[0] ) ):
key = ''.join( random.sample( args.characterset, keylen ) )
key = '-'.join( [ key[i:i+4] for i in xrange( 0, keylen, 4 ) ] )
print key
# selected password will automatically be selected
# or it can be set to any bash acceptable character
# set for a password.
STAGING_KEY = os.getenv('STAGING_KEY', "BLANK")
punctuation = '!#%&()*+,-./:;<=>?@[]^_{|}~'
# otherwise prompt the user for a set value to hash for the negotiation password
if STAGING_KEY == "BLANK":
choice = raw_input(
"\n [>] Enter server negotiation password, enter for random generation: "
)
if choice == "":
# if no password is entered, generation something random
STAGING_KEY = ''.join(
random.sample(string.ascii_letters + string.digits + punctuation,
32))
else:
STAGING_KEY = hashlib.md5(choice).hexdigest()
elif STAGING_KEY == "RANDOM":
STAGING_KEY = ''.join(
random.sample(string.ascii_letters + string.digits + punctuation, 32))
# the installation path for Empire, defaults to auto-calculating it
# set manually if issues arise
currentPath = os.path.dirname(os.path.realpath(__file__))
empireIndex = currentPath.rfind("Empire")
if empireIndex < 0:
empireIndex = currentPath.rfind("empire")
if empireIndex < 0:
INSTALL_PATH = "/".join(os.getcwd().split("/")[0:-1]) + "/"
else:
def __getOrganismsToReproduce(self):
return random.sample(self.organisms, (2 * int(((len(self.organisms) - 1) / 3))))
def saltpair(num=12):
chars = string.ascii_lowercase + string.ascii_uppercase
chars += chars # Allows for duplicate char pair (e.g. 'DD')
return [''.join(random.sample(chars, 2)) for x in xrange(num)]
def runTest(self):
"""Crypto.Random.new()"""
# Import the Random module and try to use it
from Crypto import Random
randobj = Random.new()
x = randobj.read(16)
y = randobj.read(16)
self.assertNotEqual(x, y)
z = Random.get_random_bytes(16)
self.assertNotEqual(x, z)
self.assertNotEqual(y, z)
# Test the Random.random module, which
# implements a subset of Python's random API
# Not implemented:
# seed(), getstate(), setstate(), jumpahead()
# random(), uniform(), triangular(), betavariate()
# expovariate(), gammavariate(), gauss(),
# longnormvariate(), normalvariate(),
# vonmisesvariate(), paretovariate()
# weibullvariate()
# WichmannHill(), whseed(), SystemRandom()
from Crypto.Random import random
x = random.getrandbits(16 * 8)
y = random.getrandbits(16 * 8)
self.assertNotEqual(x, y)
# Test randrange
if x > y:
start = y
stop = x
else:
start = x
stop = y
for step in range(1, 10):
x = random.randrange(start, stop, step)
y = random.randrange(start, stop, step)
self.assertNotEqual(x, y)
self.assertEqual(start <= x < stop, True)
self.assertEqual(start <= y < stop, True)
self.assertEqual((x - start) % step, 0)
self.assertEqual((y - start) % step, 0)
for i in range(10):
self.assertEqual(random.randrange(1, 2), 1)
self.assertRaises(ValueError, random.randrange, start, start)
self.assertRaises(ValueError, random.randrange, stop, start, step)
self.assertRaises(TypeError, random.randrange, start, stop, step, step)
self.assertRaises(TypeError, random.randrange, start, stop, "1")
self.assertRaises(TypeError, random.randrange, "1", stop, step)
self.assertRaises(TypeError, random.randrange, 1, "2", step)
self.assertRaises(ValueError, random.randrange, start, stop, 0)
# Test randint
x = random.randint(start, stop)
y = random.randint(start, stop)
self.assertNotEqual(x, y)
self.assertEqual(start <= x <= stop, True)
self.assertEqual(start <= y <= stop, True)
for i in range(10):
self.assertEqual(random.randint(1, 1), 1)
self.assertRaises(ValueError, random.randint, stop, start)
self.assertRaises(TypeError, random.randint, start, stop, step)
self.assertRaises(TypeError, random.randint, "1", stop)
self.assertRaises(TypeError, random.randint, 1, "2")
# Test choice
seq = list(range(10000))
x = random.choice(seq)
y = random.choice(seq)
self.assertNotEqual(x, y)
self.assertEqual(x in seq, True)
self.assertEqual(y in seq, True)
for i in range(10):
self.assertEqual(random.choice((1, 2, 3)) in (1, 2, 3), True)
self.assertEqual(random.choice([1, 2, 3]) in [1, 2, 3], True)
if sys.version_info[0] is 3:
self.assertEqual(
random.choice(bytearray(b('123'))) in bytearray(b('123')),
True)
self.assertEqual(1, random.choice([1]))
self.assertRaises(IndexError, random.choice, [])
self.assertRaises(TypeError, random.choice, 1)
# Test shuffle. Lacks random parameter to specify function.
# Make copies of seq
seq = list(range(500))
x = list(seq)
y = list(seq)
random.shuffle(x)
random.shuffle(y)
self.assertNotEqual(x, y)
self.assertEqual(len(seq), len(x))
self.assertEqual(len(seq), len(y))
for i in range(len(seq)):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
self.assertEqual(seq[i] in x, True)
self.assertEqual(seq[i] in y, True)
z = [1]
random.shuffle(z)
self.assertEqual(z, [1])
if sys.version_info[0] == 3:
z = bytearray(b('12'))
random.shuffle(z)
self.assertEqual(b('1') in z, True)
self.assertRaises(TypeError, random.shuffle, b('12'))
self.assertRaises(TypeError, random.shuffle, 1)
self.assertRaises(TypeError, random.shuffle, "1")
self.assertRaises(TypeError, random.shuffle, (1, 2))
# 2to3 wraps a list() around it, alas - but I want to shoot
# myself in the foot here! :D
# if sys.version_info[0] == 3:
# self.assertRaises(TypeError, random.shuffle, range(3))
# Test sample
x = random.sample(seq, 20)
y = random.sample(seq, 20)
self.assertNotEqual(x, y)
for i in range(20):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
z = random.sample([1], 1)
self.assertEqual(z, [1])
z = random.sample((1, 2, 3), 1)
self.assertEqual(z[0] in (1, 2, 3), True)
z = random.sample("123", 1)
self.assertEqual(z[0] in "123", True)
z = random.sample(list(range(3)), 1)
self.assertEqual(z[0] in range(3), True)
if sys.version_info[0] == 3:
z = random.sample(b("123"), 1)
self.assertEqual(z[0] in b("123"), True)
z = random.sample(bytearray(b("123")), 1)
self.assertEqual(z[0] in bytearray(b("123")), True)
self.assertRaises(TypeError, random.sample, 1)
def gen_nonce(self):
TOKEN_CHAR_LIST = "abcdefghij!@#$%"
self.nonce = ''.join(random.sample(TOKEN_CHAR_LIST, 10))
self.KEYNonce =hasher(self.nonce + self.KEY)
def chooseRandomBlocksForRandomChallenge(totalBlocks, precentage):
if totalBlocks <= 10000:
return xrange(totalBlocks)
else:
k = random.sample(xrange(totalBlocks), int(totalBlocks*precentage))
return set(k)
def generate_aes_key():
"""
Generate a random new 128-bit AES key using Pycrypto's secure Random functions.
"""
punctuation = '!#$%&()*+,-./:;<=>?@[\]^_`{|}~'
return ''.join(random.sample(string.ascii_letters + string.digits + '!#$%&()*+,-./:;<=>?@[\]^_`{|}~', 32))
def randnonzerobytes(k):
return bytes(random.sample(range(1, 256), k))
def rand_num_list(n, total):
dividers = sorted(random.sample(xrange(1, total), n - 1))
return [a - b for a, b in zip(dividers + [total], [0] + dividers)]
def pickCommonBlocks(numOfBlocks, numOfCommon): common = random.sample(xrange(numOfBlocks), numOfCommon) return common
def get_rand_keycode() :
keycode_size = 32
return random.sample(range(255), keycode_size)
# Staging Key is set up via environmental variable
# or via command line. By setting RANDOM a randomly
# selected password will automatically be selected
# or it can be set to any bash acceptable character
# set for a password.
STAGING_KEY = os.getenv('STAGING_KEY', "BLANK")
punctuation = '!#%&()*+,-./:;<=>?@[]^_{|}~'
# otherwise prompt the user for a set value to hash for the negotiation password
if STAGING_KEY == "BLANK":
choice = raw_input("\n [>] Enter server negotiation password, enter for random generation: ")
if choice == "":
# if no password is entered, generation something random
STAGING_KEY = ''.join(random.sample(string.ascii_letters + string.digits + punctuation, 32))
else:
STAGING_KEY = hashlib.md5(choice).hexdigest()
elif STAGING_KEY == "RANDOM":
STAGING_KEY = ''.join(random.sample(string.ascii_letters + string.digits + punctuation, 32))
# the installation path for Empire, defaults to auto-calculating it
# set manually if issues arise
currentPath = os.path.dirname(os.path.realpath(__file__))
empireIndex = currentPath.rfind("Empire")
if empireIndex < 0:
empireIndex = currentPath.rfind("empire")
if empireIndex < 0:
INSTALL_PATH = "/".join(os.getcwd().split("/")[0:-1])+"/"
else:
endIndex = currentPath.find("/", empireIndex)
# Staging Key is set up via environmental variable
# or via command line. By setting RANDOM a randomly
# selected password will automatically be selected
# or it can be set to any bash acceptable character
# set for a password.
STAGING_KEY = os.getenv('STAGING_KEY', "BLANK")
punctuation = '!#%&()*+,-./:;<=>?@[]^_{|}~'
# otherwise prompt the user for a set value to hash for the negotiation password
if STAGING_KEY == "BLANK":
choice = raw_input("\n [>] Enter server negotiation password, enter for random generation: ")
if choice == "":
# if no password is entered, generation something random
STAGING_KEY = ''.join(random.sample(string.ascii_letters + string.digits + punctuation, 32))
else:
STAGING_KEY = hashlib.md5(choice).hexdigest()
elif STAGING_KEY == "RANDOM":
STAGING_KEY = ''.join(random.sample(string.ascii_letters + string.digits + punctuation, 32))
# the installation path for Empire, defaults to auto-calculating it
# set manually if issues arise
currentPath = os.path.dirname(os.path.realpath(__file__))
empireIndex = currentPath.rfind("Empire")
if empireIndex < 0:
empireIndex = currentPath.rfind("empire")
if empireIndex < 0:
INSTALL_PATH = "/".join(os.getcwd().split("/")[0:-1])+"/"
else:
endIndex = currentPath.find("/", empireIndex)
tag='None',
bin="None")
if args.compress:
if args.compress >= 2:
comp_level = 9
else:
comp_level = 6
print(f"* Compressing (level {comp_level})...")
file_buffer = compress(file_buffer, preset=comp_level)
substitutes['compression'] = 'True'
if args.password is not None:
print("* Encrypting...")
if args.password == '':
password = ''.join(random.sample(string.hexdigits, 12))
else:
password = args.password
print(" ->", password)
hasher = SHA3_256.new(password.encode('utf-8'))
key_hash = hasher.digest()
aes_cipher = AES.new(key_hash, AES.MODE_EAX)
file_buffer, tag = aes_cipher.encrypt_and_digest(file_buffer)
nonce = aes_cipher.nonce
substitutes['aes_enc'] = 'True'
substitutes['tag'] = repr(tag)
substitutes['nonce'] = repr(nonce)
