def generate_arb_discrete_samples(n, params):
try:
assert len(params) >= 1
probs = [float(p) for p in params]
assert math.isclose(sum(probs), 1.0, abs_tol=0.001)
except (ValueError, AssertionError):
abort("invalid arb_discrete parameters")
for _ in range(n):
yield arb_discrete(probs)
def generate_geometric_samples(n, params):
try:
assert len(params) == 1
p = float(params[0])
assert 0 <= p <= 1
except (ValueError, AssertionError):
abort("invalid geometric parameters")
for _ in range(n):
yield geometric(p)
def generate_poisson_samples(n, params):
try:
assert len(params) == 1
L = float(params[0])
assert L > 0
except (ValueError, AssertionError):
abort("invalid poisson parameters")
for _ in range(n):
yield poisson(L)
def generate_bernoulli_samples(n, params):
try:
assert len(params) == 1
p = float(params[0])
assert 0 <= p <= 1
except (ValueError, AssertionError):
abort("invalid bernoulli parameters")
for _ in range(n):
yield bernoulli(p)
def generate_exponential_samples(n, params):
try:
assert len(params) == 1
L = float(params[0])
assert L > 0
except (ValueError, AssertionError):
abort("invalid exponential parameters")
for _ in range(n):
yield exponential(L)
def generate_uniform_samples(n, params):
try:
assert len(params) == 2
a = float(params[0])
b = float(params[1])
assert a <= b
except (ValueError, AssertionError):
abort("invalid uniform parameters")
for _ in range(n):
yield uniform(a, b)
def generate_gamma_samples(n, params):
try:
assert len(params) == 2
a = int(params[0])
L = float(params[1])
assert a >= 1
assert L > 0
except (ValueError, AssertionError):
abort("invalid gamma parameters")
for _ in range(n):
yield gamma(a, L)
def generate_neg_binomial_samples(n, params):
try:
assert len(params) == 2
k = int(params[0])
p = float(params[1])
assert k >= 1
assert 0 <= p <= 1
except (ValueError, AssertionError):
abort("invalid neg_binomial parameters")
for _ in range(n):
yield neg_binomial(k, p)
def main():
n, dist, params = parse_arguments()
# random seed
seed = time.time()
random.seed(seed)
try:
generator = getattr(sample_generators, f"generate_{dist}_samples")
samples = generator(n, params)
except KeyError:
abort("distribution not recognized")
print_report(samples)
def generate_normal_samples(n, params):
try:
assert len(params) == 2
u = float(params[0])
s = float(params[1])
assert s >= 0
except (ValueError, AssertionError):
abort("invalid normal parameters")
count = 0
while count < n:
for x in normal(u, s):
yield x
count += 1
def connection():
from helpers import abort
cnx = None
try:
cnx = Connect(host='timbess.net',
user='******',
password='******',
database='test')
curr = cnx.cursor(cursor=DictCursor)
return cnx, curr
except MySQLError as e:
if cnx is not None:
cnx.close()
current_app.logger.exception(e)
abort(500, message='Failed to connect to database')
#!/usr/bin/env python3
import sys
import binascii
sys.path.append('..')
from helpers import abort, xor
from base64 import b64encode, b64decode
if __name__ == "__main__":
if len(sys.argv) == 2:
i1 = binascii.unhexlify(sys.argv[1])
print(str(b64encode(i1), 'ascii'))
elif len(sys.argv) == 3 and sys.argv[1] == '-d':
o1 = b64decode(sys.argv[2])
print(str(binascii.hexlify(o1), 'ascii'))
else:
abort(f'{sys.argv[0]}: [-d] input')
except Exception:
pass
return matches
if __name__ == "__main__":
if len(sys.argv) == 1:
blocksize = ecb_determine_blocksize()
is_ecb = aes_mode_oracle(oracle(32 * b"a", key))
print("block size:", blocksize)
print("is ECB:", is_ecb)
print()
if not is_ecb:
abort("** cipher doesn't use ECB mode")
cracked = b""
written = 0
while len(cracked) <= len(b64decode(append)):
cracked_block = ecb_crack_block(blocksize, cracked or 16 * b"a",
written)
cracked += cracked_block
written += len(cracked_block)
print(pkcs7_unpad(cracked).decode())
print("plain len: ", len(b64decode(append)))
print("cracked len: ", len(cracked))
else:
abort(f'{sys.argv[0]}: filename')
#!/usr/bin/env python3
import sys
sys.path.append('..')
from helpers import abort
from block_crypto import aes_cbc_encrypt, aes_cbc_decrypt, pkcs7_pad
from base64 import b64encode, b64decode
if __name__ == "__main__":
if len(sys.argv) == 4 and not sys.argv[1] == '-d':
with open(sys.argv[1], 'rb') as f:
plain = f.read().rstrip()
key = sys.argv[2].encode()
iv = bytes([int(sys.argv[3])])
plain = pkcs7_pad(plain, 16)
ciphertext = aes_cbc_encrypt(plain, key, iv)
print(b64encode(ciphertext))
elif len(sys.argv) == 5 and sys.argv[1] == '-d':
with open(sys.argv[2], 'rb') as f:
cipher = b64decode(f.read().rstrip())
key = sys.argv[3].encode()
iv = bytes([int(sys.argv[4])])
plaintext = aes_cbc_decrypt(cipher, key, iv).decode()
print(plaintext)
else:
abort(f'{sys.argv[0]}: [-d] filename password iv')
#!/usr/bin/env python3
import sys
import binascii
sys.path.append('..')
from helpers import abort, xor
if __name__ == "__main__":
if len(sys.argv) == 3 and not sys.argv[1] == '-h':
i1 = binascii.unhexlify(sys.argv[1])
i2 = binascii.unhexlify(sys.argv[2])
xored = xor(i1, i2)
print(str(binascii.hexlify(xored), 'ascii'))
elif len(sys.argv) == 4 and sys.argv[1] == '-h':
i1 = binascii.unhexlify(sys.argv[2])
i2 = binascii.unhexlify(sys.argv[3])
xored = xor(i1, i2)
print(str(xored, 'ascii'))
else:
abort(f'{sys.argv[0]}: [-h] input1 input2')
#!/usr/bin/env python3
import sys
import binascii
sys.path.append('..')
from helpers import abort
from base64 import b64decode
from xor import crack_multibyte_xor
if __name__ == "__main__":
if len(sys.argv) == 2:
with open(sys.argv[1]) as input_file:
cipher = input_file.read().rstrip()
cipher = b64decode(cipher)
plaintext, key = crack_multibyte_xor(cipher)
print(plaintext.decode())
print("key: ", key)
else:
abort(f'{sys.argv[0]}: filename')
#!/usr/bin/env python3
import sys
sys.path.append('..')
from helpers import abort
from block_crypto import pkcs7_pad
if __name__ == "__main__":
if len(sys.argv) == 3:
padded = pkcs7_pad(sys.argv[1].encode(), int(sys.argv[2]))
print(padded)
else:
abort(f'{sys.argv[0]}: text pad_length')
#!/usr/bin/env python3
import sys
import binascii
sys.path.append('..')
from helpers import abort, xor
from xor import crack_singlebyte_xor
if __name__ == "__main__":
if len(sys.argv) == 2:
plaintext = crack_singlebyte_xor(binascii.unhexlify(
sys.argv[1]))[0].decode()
print(plaintext)
else:
abort(f'{sys.argv[0]}: input')
