Hybrid Cryptography Examples

Let's consider a basic example of hybrid

Bob receives the CTM and decrypts it to cryptography. A combination of symmetric produce a plaintext message. Both Alice and and asymmetric encryption can work Bob need to know the symmetric key. But to do this, Alice must transmit the symmetric together to transmit a message over an key to Bob over an unsecured channel using unsecure channel, as shown in the figure. In this scenario, Alice is the sender and an asymmetric algorithm. Alice uses Bob's Bob is the receiver. If Alice wants to send public key to encrypt the symmetric key for a confidential message to Bob, she should transmission. This produces a ciphertext encrypt the message using symmetric key (CTK), which Alice sends to Bob. Bob encryption. Alice doesn't have to worry now takes the CTK and decrypts it using his about the size of the message. This private key. Now Bob has the symmetric key produces a ciphertext message (CTM). he needs to decrypt the message.

Non-repudiation is also a form of proof of origin, so this example demonstrates that as part of this process. Alice needs to send a confidential message to Bob, as shown in the next figure. She also needs confirmation of receipt by Bob and knows that Bob will need to prove the message came from her. This also means that Alice cannot repudiate the message (claim she did not send it) afterward.

As with the previous example, Alice first encrypts the text of her message using symmetric encryption and her key (that she shares with Bob, of course). Since she's using symmetric encryption, she does not need to worry about how large the message is (since symmetric encryption runs very fast). This produces the CTM, which she sends to Bob. But how do they exchange the symmetric key and keep it confidential?

Alice encrypts this key with an asymmetric algorithm using Bob's public key. The | resulting CTK, or key encapsulated key, is one that only Bob can decrypt (since he's the only one who has his private key that corresponds to his public key). So Alice sends the CTK to Bob. He decrypts it using his private key, and now he can decrypt the message.

Now Alice wants to provide Bob with a way to verify the integrity of the decrypted message. She hashes her original unencrypted message, encrypts it with her private key, and appends that encrypted message digest to the message (or sends it separately) to Bob. Bob now does two things: he decrypts the encrypted message digest, and then he compares it bit by bit to a message digest he computes locally on his received, decrypted copy of the message. If they match, the message and the digest are proved to have come from Alice.

If, later on, Alice attempts to claim she never sent this message, Bob can point to the two message digests (the one he generated locally based on the received, decrypted message, and the one "Alice" sent him that he decrypted with her public key).

Since the asymmetrically encrypted message digest that Alice sent could only be decrypted with Alice's public key, either she is not being honest in her claim to Bob, or her private key has been compromised and is being used by someone else.