def dh_decrypt(priv, ciphertext, aliceVer = None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" # ciphertext be (iv, ciphertext, tag, sender_pub, sig) # bob decrypting: check sig using alice's pub ver key, # then decrypt using shared key derived from priv (bob's private key) # check input parameter format if (not isinstance(ciphertext, tuple)) or (isinstance(ciphertext, tuple) and len(ciphertext) != 5): raise Exception("Expecting tuple (iv, ciphertext, tag, sender public key, signature).") iv, encmsg, tag, sender_pub, sig = ciphertext # verify signature if aliceVer: if not sig: raise Exception("Signature required before decyption.") elif not do_ecdsa_verify(EcGroup(), aliceVer, sig, sha256(encmsg).digest()): raise Exception("Signature verification failed.") # shared key = bob priv x alice's pub point shared_key = priv * sender_pub # hash shared_key = sha256(shared_key.export()).digest() # decrypt aes = Cipher("aes-256-gcm") plaintext = aes.quick_gcm_dec(shared_key, iv, encmsg, tag) return plaintext.encode("utf-8")
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ aes = Cipher("aes-128-gcm") plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) return plain.encode("utf8")
def decrypt_message(K, iv, ciphertext, tag, key_length=16): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ aes = Cipher("aes-{}-gcm".format(key_length * 8)) plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) return plain.encode("utf8")
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ ## YOUR CODE HERE aes = Cipher("aes-128-gcm") # Initialize AES-GCM with 128 bit keys plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) return plain.encode("utf8")
def dh_decrypt(priv, ciphertext, aliceVer=None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" ## YOUR CODE HERE iv, ciphertext, tag, pub_enc = ciphertext freshKey = pub_enc.pt_mul(priv).export()[:16] aes = Cipher("aes-128-gcm") plaintext = aes.quick_gcm_dec(freshKey, iv, ciphertext, tag) return plaintext.encode("utf8")
def dh_decrypt(priv, ciphertext, aliceVer=None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" iv, enc_msg, tag, pub_enc = ciphertext shared_key = pub_enc.pt_mul(priv).export() hashed_shared_key = sha256(shared_key).digest() aes = Cipher("aes-128-gcm") plaintext = aes.quick_gcm_dec(hashed_shared_key[:16], iv, enc_msg, tag).encode("utf-8") return plaintext
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ ## YOUR CODE HERE try: aes = Cipher("aes-128-gcm") plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) except: raise Exception("decryption failed") return plain.encode("utf8")
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ ## YOUR CODE HERE # we declare the aes cipher aes = Cipher("aes-128-gcm") # we decode the ciphertext plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) # we return the unencrypted message return plain.encode("utf8")
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ ## YOUR CODE HERE tests aes = Cipher("aes-128-gcm") try: m = aes.quick_gcm_dec(K, iv, ciphertext,tag) m = m.decode("utf8") except: raise Exception('decryption failed') return m
def decrypt_message(K, iv, ciphertext, tag, key_length=128): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ if key_length not in [128, 192, 256]: raise Exception("Invalid key length") aes = Cipher("aes-%s-gcm" % str(key_length)) plain = aes.quick_gcm_dec(K, iv, ciphertext, tag) return plain.encode("utf8")
def decrypt_message(K, iv, ciphertext, tag): """ Decrypt a cipher text under a key K In case the decryption fails, throw an exception. """ plain = '' aes = Cipher("aes-128-gcm") try: plain = aes.quick_gcm_dec(K, iv, ciphertext,tag) plain = plain.decode("utf8") except: raise Exception('decryption failed') return plain
def dh_decrypt(priv, iv, ciphertext, tag, pub_A, aliceVer = None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" # Calculate shared_K, _ = pub_A.pt_mul(priv).get_affine() shared_K = sha256(shared_K.repr()).hexdigest() shared_K = shared_K[:32] aes = Cipher("aes-256-gcm") try: plaintext = aes.quick_gcm_dec(shared_K, iv, ciphertext, tag) except: raise Exception("decryption failed") return plaintext.decode("utf8")
def dh_decrypt(priv_receiver, ciphertext, iv, tag, pub_sender, signature = None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" shared_key = dh_get_shared_key(pub_sender, priv_receiver) aes = Cipher("aes-256-gcm") plaintext = aes.quick_gcm_dec(shared_key, iv, ciphertext, tag) message = plaintext.decode("utf8") G = EcGroup() if signature: verify = ecdsa_verify(EcGroup(), pub_sender, message, signature) if not verify: raise Exception("Could not verify message") return message
def dh_decrypt(priv, ciphertext): """ Decrypt a received message encrypted using your public key, of which the private key is provided""" Group1,private, public = dh_get_key()#generate new DH pair for Bob iv=ciphertext[0] cipher=ciphertext[1] tag=ciphertext[2] pubA=ciphertext[3] #Bob derives shared secret key by multiplying his public key with Alice's private key shared2 = pubA.pt_mul(priv)#qA * dB print "key from dec is", shared2 hashedKey=sha256(shared2.export()).digest() aes = Cipher("aes-128-gcm") plain = aes.quick_gcm_dec(hashedKey[:16], iv, cipher, tag)#where to get IV and tag from ??? return plain.encode("utf8")
def dh_decrypt(priv, ciphertext): """ Decrypt a received message encrypted using your public key, of which the private key is provided""" Group1, private, public = dh_get_key() #generate new DH pair for Bob iv = ciphertext[0] cipher = ciphertext[1] tag = ciphertext[2] pubA = ciphertext[3] #Bob derives shared secret key by multiplying his public key with Alice's private key shared2 = pubA.pt_mul(priv) #qA * dB print "key from dec is", shared2 hashedKey = sha256(shared2.export()).digest() aes = Cipher("aes-128-gcm") plain = aes.quick_gcm_dec(hashedKey[:16], iv, cipher, tag) #where to get IV and tag from ??? return plain.encode("utf8")
def dh_decrypt(priv, ciphertext, aliceVer=None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" ## YOUR CODE HERE # The ciphertext is 4 things combined alice_pub, iv, encrypted_text, tag = ciphertext bob_priv = priv assert isinstance(bob_priv, Bn) # derive the shared key the same way as before shared_key_point = bob_priv * alice_pub # Now bob_priv is a scalar shared_key_point_binary = shared_key_point.export() shared_key = sha256(shared_key_point_binary).digest() aes = Cipher("aes-256-gcm") plain = aes.quick_gcm_dec(shared_key, iv, encrypted_text, tag) return plain.encode("utf8")
def dh_decrypt(priv, ciphertext, aliceVer = None): """ Decrypt a received message encrypted using your public key, of which the private key is provided. Optionally verify the message came from Alice using her verification key.""" ## YOUR CODE HERE pub = ciphertext[0] iv = ciphertext[1] tag = ciphertext[3] # We want d_B Q_A = d_A d_B G, to use as shared key secret = pub.pt_mul(priv) # x, y = secret.get_affine() # shared = x.binary()[:24] shared = sha256(secret.export()).digest() # Perform decryption with shared key aes = Cipher("aes-256-gcm") try: plain = aes.quick_gcm_dec(shared, iv, ciphertext[2], tag) except: raise RuntimeError("decryption failed") return plain.encode("utf8")