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")