def test_unsupported_mgf1_hash_algorithm_whirlpool_decrypt(self):
private_key = RSA_KEY_512.private_key(backend)
with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_PADDING):
private_key.decrypt(
b"0" * 64,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.Whirlpool()),
algorithm=hashes.Whirlpool(),
label=None))
class TestWhirlpool(object):
test_whirlpool = generate_hash_test(
load_hash_vectors,
os.path.join("hashes", "whirlpool"),
[
"iso-test-vectors.txt",
],
hashes.Whirlpool(),
)
test_whirlpool_long_string = generate_long_string_hash_test(
hashes.Whirlpool(),
("0c99005beb57eff50a7cf005560ddf5d29057fd86b2"
"0bfd62deca0f1ccea4af51fc15490eddc47af32bb2b"
"66c34ff9ad8c6008ad677f77126953b226e4ed8b01"),
)
def post(self, request):
form = USF(request.POST)
if not form.is_valid():
raise RuntimeError("Invalid HTML Form submitted")
password = form.cleaned_data['password']
pseudonym = form.cleaned_data['pseudonym']
kdf = KDF(
algorithm=hashes.Whirlpool(),
length=int(
32 + 32), # 32: Edwards25519 seed, second 32: Curve25519 seed
salt=whirlpool(pseudonym.encode()),
iterations=int(1e6),
backend=default_backend())
key = kdf.derive(password.encode())
edkey = signfool.SigningKey(
key[0:32]
) # Use the first 32-bytes of the derived key as Edwards25519 seed
cvkp = pubfool.PrivateKey(
key[32:64]) # Use the second half as Curve25519 seed
try:
sig = db.get('gks').sign(cvkp.public_key.encode(encoder=b64))
except KeyError:
return render(request, 'freakedup.html',
{'err': "You are not part of a group, yet"})
db.set("user-edkeys", edkey)
db.set("user-cvkeys", cvkp)
db.set("user-keysig", sig)
edkey_fingerprint = base64.b64encode(whirlpool(
edkey._signing_key)).decode()
cvkey_fingerprint = base64.b64encode(whirlpool(
cvkp._private_key)).decode()
ctx = dict(edkey_fp=edkey_fingerprint,
cvkey_fp=cvkey_fingerprint,
sig=base64.b64encode(sig).decode())
return render(request, 'user.post.html', ctx)
def __calc_data_checksum(self, data=None):
"""
Calculate the checksum of the data in the repo
Return checksum
"""
# Whirlpool instance used to calculate the checksum
digest = hashes.Hash(hashes.Whirlpool(), backend=default_backend())
# If no data provided, use the repository data
if not data:
data = bytes(json.dumps(self.__data), 'utf-8')
# Calculate and return the checksum
digest.update(data)
return digest.finalize()
load_hash_vectors,
os.path.join("hashes", "ripemd160"),
[
"ripevectors.txt",
],
hashes.RIPEMD160(),
)
test_RIPEMD160_long_string = generate_long_string_hash_test(
hashes.RIPEMD160(),
"52783243c1697bdbe16d37f97f68f08325dc1528",
)
@pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.Whirlpool()),
skip_message="Does not support Whirlpool",
)
@pytest.mark.hash
class TestWhirlpool(object):
test_whirlpool = generate_hash_test(
load_hash_vectors,
os.path.join("hashes", "whirlpool"),
[
"iso-test-vectors.txt",
],
hashes.Whirlpool(),
)
test_whirlpool_long_string = generate_long_string_hash_test(
hashes.Whirlpool(),
class TestWhirlpool(object):
test_Whirlpool = generate_base_hash_test(
hashes.Whirlpool(),
digest_size=64,
block_size=64,
)
"""
algo_run = ['RIPEMD160']
digest_prime = hashes.Hash(hashes.RIPEMD160(), backend=backend)
trial = Timer("digest.update(message); digest.finalize()", setup)
algo_run.append(trial.repeat(RUN_COUNT, 1))
set_run.append(algo_run)
algo_run = ['SHA512']
digest_prime = hashes.Hash(hashes.SHA512(), backend=backend)
trial = Timer("digest.update(message); digest.finalize()", setup)
algo_run.append(trial.repeat(RUN_COUNT, 1))
set_run.append(algo_run)
algo_run = ['Whirlpool']
digest_prime = hashes.Hash(hashes.Whirlpool(), backend=backend)
trial = Timer("digest.update(message); digest.finalize()", setup)
algo_run.append(trial.repeat(RUN_COUNT, 1))
set_run.append(algo_run)
lib_run.append(set_run)
result.append(lib_run)
# ********** ######################## ******************************************
# ********** BEGIN 'PYCRYPTO' LIBRARY ******************************************
# ********** ######################## ******************************************
lib_run = ['PyCrypto']
def create_test_list():
hash_msg_bitsizes = tuple(pow(2, _) for _ in range(8, 24))
symm_msg_bitsizes = tuple(pow(2, _) for _ in range(8, 24))
prng_msg_bitsizes = tuple(pow(2, _) for _ in range(8, 18))
return [
TestArgRange(TestPythonRandom, msgbits=prng_msg_bitsizes),
TestArgRange(TestPythonSysRandom, msgbits=prng_msg_bitsizes),
TestArgRange(TestPyCryptPRNG, msgbits=prng_msg_bitsizes),
TestArgRange(TestGenPrime, bits=(32, 64, 128, 256, 512)),
# cryptography symmetric ciphers
TestArgRange(TestCryptCipher, algorithms.AES, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.TripleDES, keybits=64, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.TripleDES, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.TripleDES, keybits=192, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.Blowfish, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.CAST5, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.ARC4, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.IDEA, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.SEED, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestCryptCipher, algorithms.Camellia, keybits=256, msgbits=symm_msg_bitsizes),
# pycrypt symmetric ciphers
TestArgRange(TestPyCryptCipher, Crypto.Cipher.AES, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.DES, keybits=64, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.DES3, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.DES3, keybits=192, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.Blowfish, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.CAST, keybits=128, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.ARC4, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.XOR, keybits=256, msgbits=symm_msg_bitsizes),
TestArgRange(TestPyCryptCipher, Crypto.Cipher.ARC2, keybits=256, msgbits=symm_msg_bitsizes),
# cryptography hashes
TestArgRange(TestCryptHash, hashes.SHA224(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.SHA256(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.SHA384(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.SHA512(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.SHA1(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.MD5(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.RIPEMD160(), msgbits=hash_msg_bitsizes),
TestArgRange(TestCryptHash, hashes.Whirlpool(), msgbits=hash_msg_bitsizes),
# pycrypt hashes
TestArgRange(TestPyCryptHash, Crypto.Hash.SHA224, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.SHA256, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.SHA384, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.SHA512, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.SHA, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.MD5, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.RIPEMD, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.MD2, msgbits=hash_msg_bitsizes),
TestArgRange(TestPyCryptHash, Crypto.Hash.MD4, msgbits=hash_msg_bitsizes),
# cryptography rsa
TestArgRange(TestCryptRsa, modbits=(1024,2048,4096), msgbits=(2,256,512,1024)),
# PyCrypto rsa
TestArgRange(TestPyCryptRsa, modbits=(1024,2048,4096), msgbits=(2,256,512,1024)),
# now some tests to see how very simple operations perform
TestEval("pass"),
TestEval("1+2"),
TestEval("8*9"),
TestLambda(nop),
TestLambda(lambda: 1),
TestLambda(lambda: 1+2),
TestLambda(lambda: 1+2+3+4),
TestLambda(lambda: 8*9),
TestLambda(lambda: pow(1, 1, 2)),
# some elliptic curve crypto
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT571R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT409R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT283R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT233R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT163R2),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT571K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT409K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT283K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT233K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECT163K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP521R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP384R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP256R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP256K1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP224R1),
TestCryptEc(cryptography.hazmat.primitives.asymmetric.ec.SECP192R1),
]
import signal
import sys
import time
#Reads line by line, since reading entire file will consume too much ram
choice = 0;
numhashes = 0;
filename = "";
file1 = "";
encoded_string = "";
choices = {
1 : hashes.SHA256(),
2 : hashes.MD5(),
3 : hashes.RIPEMD160(),
4 : hashes.Whirlpool(),
}
def menu():
global choice;
invalid = True
while invalid :
print ("\n\
Please Select a Hashing Algorithm:\n\
1. sha2 (256-bit hash)\n\
2. md5 (128-bit hash)\n\
3. ripemd160 (160-bit hash)\n\
4. whirlpool (512-bit hash)\n\
5. Exit")
