Unit 3
Unit 3
Symmetric-Key Cryptography: Symmetric-key cryptography uses a single key for both encryption
and decryption. Encryption and decryption algorithm are inverse of each other.
Example:
To create the cipher text from the plaintext John uses an encryption algorithm and a key.
To create the plaintext from cipher text, Bob uses the decryption algorithm and the same key.
Asymmetric-Key cryptography: It is also called public key cryptography. In public key cryptography
two keys: a private key and a public key is used. Encryption is done through the public key and
decryption through private key. Receiver creates both the keys and is responsible for distributing its
public key to the communication community.
Example:
The sender (say John) uses the public key to encrypt the plaintext into ciphertext and the receiver (say
Bob) uses his private key to decrypt the ciphertext.
Unlike symmetric key cryptography, we do not find historical use of public-key cryptography. It is a
relatively new concept.
Symmetric cryptography was well suited for organizations such as governments, military, and big
financial corporations were involved in the classified communication.
With the spread of more unsecure computer networks in last few decades, a genuine need was felt to
use cryptography at larger scale. The symmetric key was found to be non-practical due to challenges it
faced for key management. This gave rise to the public key cryptosystems.
Lets take,
P = 10
D=2
E1 = 3
Therefore,
E2 = E1D mod P
= 32 mod 10
= 9 mod 10
=9
Now, public keys are (E1, E2, P) i.e. (3, 9, 10)
Encryption
Lets take,
R=1
PT = 4
therefore,
C1 = E1R mod P
= 31 mod 10
= 3 mod 10
=3
C2 = (PT * E2R) mod P
= (4 * 91) mod 10
= 36 mod 10
=6
Decryption
9 *x mod 10 = 1
9 * 9 mod 10 = 1
81 mod 10 = 1
1=1 (i.e. x = 9)
Hence proved
Therefore, from 1 we get
PT = [6 * 9] mod 10
= [6 * 9] mod 10
= 54 mod 10
=4
M - Plaintext
H - Hash function
h - Hash digest
‘+’ - Bundle both plaintext and digest
E - Encryption
D - Decryption
The image above shows the entire process, from the signing of the key to its verification. So, go through
each step to understand the procedure thoroughly.
Step 1: M, the original message is first passed to a hash function denoted by H# to create a digest.
Step 2: Next, it bundles the message together with the hash digest h and encrypts it using the sender’s
private key.
Step 3: It sends the encrypted bundle to the receiver, who can decrypt it using the sender’s public
key.
Step 4: Once it decrypts the message, it is passed through the same hash function (H#), to generate a
similar digest.
Step 5: It compares the newly generated hash with the bundled hash value received along with the
message. If they match, it verifies data integrity.
There are two industry-standard ways to implement the above methodology. They are:
1. RSA Algorithm
2. DSA Algorithm
Both the algorithms serve the same purpose, but the encryption and decryption functions differ quite a
bit. So, now that you understand how it is supposed to function while verifying the signature, let’s deep
dive into our focus for today, the DSA Algorithm.
Block Diagram of Digital Signature
A digital signature is a type of electronic signature based on cryptography and used to authenticate the
identity of the sender of a message or the signer of a document and to ensure that the original content of
the message or document is unchanged.
The block diagram of the digital signature process is as follows:
Message or Document: This is the data or document that needs to be signed.
Hashing: The document or message is converted into a fixed-length hash using a cryptographic hash
function.
Encryption: The hash is then encrypted using the sender's private key.
Signature: The encrypted hash is the document's digital signature.
Verification: The signature is then verified using the sender's public key to ensure the signature's
validity and the document's authenticity.
Explanation of the Block Diagram
The digital signature block diagram outlines the process of creating and verifying digital signatures.
The process begins with a message being sent from one party to another. This message is then run
through a cryptographic hashing algorithm, which produces a hash of the message.
Then, the hash is encrypted using the sender's private key. The encrypted hash is then attached to the
original message, forming the digital signature.
After that, the recipient verifies the digital signature by decrypting the hash with the sender's public
key and then comparing it to a new hash generated from the original message. This decrypting
process assures that the message has not been altered in transit and can be trusted as coming from the
sender. Once again, the digital signature proves that the data is from a trusted source and has not been
changed.
DSA Algorithm?
Digital Signatures Algorithm is a FIPS (Federal Information Processing Standard) for digital signatures.
It was proposed in 1991 and globally standardized in 1994 by the National Institute of Standards and
Technology (NIST). It functions on the framework of modular exponentiation and discrete logarithmic
problems, which are difficult to compute as a force-brute system.
DSA Algorithm provides three benefits, which are as follows:
Message Authentication: You can verify the origin of the sender using the right key combination.
Integrity Verification: You cannot tamper with the message since it will prevent the bundle from
being decrypted altogether.
Non-repudiation: The sender cannot claim they never sent the message if verifies the signature.
The image above shows the entire procedure of the DSA algorithm. You will use two different functions
here, a signing function and a verification function. The difference between the image of a typical digital
signature verification process and the one above is the encryption and decryption part. They have
distinct parameters, which you will look into in the next section of this lesson on the DSA Algorithm.
The Covid-19 pandemic has given a new life to the work-from-home initiative, taking the corporate
world into an untapped phase. Without a doubt, most of the users reading this have had to digitally sign
some official documents over the past couple of years because of the lack of face-to-face interaction and
standard distance constraints. To maintain the authenticity and integrity of such documents holding
critical information, the DSA Algorithm was proposed and passed as a global standard for verifying
digital signatures.
Before moving forward with the algorithm, you will get a refresher on asymmetric encryption, since it
verifies digital signatures according to asymmetric cryptography architecture, also known as public-
key cryptography architecture.
What Is Asymmetric Encryption?
You utilize two distinct keys in asymmetric encryption methods, one for encryption and the other for
decryption. You use the public key for encryption; meanwhile, you use the private key for decryption.
However, you must generate both keys from the receiver’s end.
Using separate keys for encryption and decryption, as seen in the figure above, has helped eliminate key
exchange, as seen in the case of symmetric encryption.
For example, if Alice needs to send a message to Bob, both the private and public keys must belong to
Bob.
The process for the above image is as follows:
Step 1: Alice first uses Bob’s public key to encrypt the message
Step 2: The encrypted message reaches Bob
Step 3: Bob decrypts the message with his secret key
This eliminates the requirement for the sender and recipient to exchange any secret keys, minimizing the
window of opportunity for exploitation.
Now that you learned how asymmetric encryption happens, you will look at how the digital signature
architecture is set up.
Become a Certified Ethical Hacker!
CEH v12 - Certified Ethical Hacking CourseEXPLORE PROGRAM
M - Plaintext
H - Hash function
h - Hash digest
‘+’ - Bundle both plaintext and digest
E - Encryption
D - Decryption
The image above shows the entire process, from the signing of the key to its verification. So, go through
each step to understand the procedure thoroughly.
Step 1: M, the original message is first passed to a hash function denoted by H# to create a digest.
Step 2: Next, it bundles the message together with the hash digest h and encrypts it using the sender’s
private key.
Step 3: It sends the encrypted bundle to the receiver, who can decrypt it using the sender’s public
key.
Step 4: Once it decrypts the message, it is passed through the same hash function (H#), to generate a
similar digest.
Step 5: It compares the newly generated hash with the bundled hash value received along with the
message. If they match, it verifies data integrity.
There are two industry-standard ways to implement the above methodology. They are:
1. RSA Algorithm
2. DSA Algorithm
Both the algorithms serve the same purpose, but the encryption and decryption functions differ quite a
bit. So, now that you understand how it is supposed to function while verifying the signature, let’s deep
dive into our focus for today, the DSA Algorithm.
Block Diagram of Digital Signature
A digital signature is a type of electronic signature based on cryptography and used to authenticate the
identity of the sender of a message or the signer of a document and to ensure that the original content of
the message or document is unchanged.
The image above shows the entire procedure of the DSA algorithm. You will use two different functions
here, a signing function and a verification function. The difference between the image of a typical digital
signature verification process and the one above is the encryption and decryption part. They have
distinct parameters, which you will look into in the next section of this lesson on the DSA Algorithm.
Steps in DSA Algorithm
Keeping the image above in mind, go ahead and see how the entire process works, starting from creating
the key pair to verifying the signature at the end.
1. Key Generation
There are two steps in the key generation process: parameter generation and per-user keys.
Parameter Generation
Initially a user needs to choose a cryptographic hash function (H) along with output length in bits |H|.
Modulus length N is used in when output length |H| is greater.
Then choose a key length L where it should be multiple of 64 and lie in between 512 and 1024 as per
Original DSS length. However, lengths 2048 or 3072 are recommended by NIST for lifetime key
security.
The values of L and N need to be chosen in between (1024, 60), (2048, 224), (2048, 256), or (3072,
256) according to FIPS 186-4. Also, a user should chose modulus length N in such a way that
modulus length N should be less than key length (N<L) and less than and equal to output length
(N<=|H|).
Later a user can choose a prime number q of N bit and another prime number as p of L bit in such a
way that p-1 is multiple of q. And then choose h as an integer from the list ( 2……..p-2).
Once you get p and q values, find out
g = h^(p-1)/q*mod(p). If you get g = 1, please try another value for h and compute again for g except 1.
p, q and g are the algorithm parameters that are shared amongst different users of the systems.
Per-user Keys
To compute the key parameters for a single user, first choose an integer x (private key) from the list
(1…….q-1), then compute the public key, y=g^(x)*mod(p).
2. Signature Generation
It passes the original message (M) through the hash function (H#) to get our hash digest(h).
It passes the digest as input to a signing function, whose purpose is to give two variables as output, s,
and r.
Apart from the digest, you also use a random integer k such that 0 < k < q.
To calculate the value of r, you use the formula r = (gk mod p) mod q.
To calculate the value of s, you use the formula s = [K-1(h+x . R)mod q].
It then packages the signature as {r,s}.
The entire bundle of the message and signature {M,r,s} are sent to the receiver.
3. Key Distribution
While distributing keys, a signer should keep the private key (x) secret and publish the public key (y)
and send the public key (y) to the receiver without any secret mechanism.
Signing
Signing of message m should be done as follows:
first choose an integer k from (1……q-1)
compute
r = g^(k)*mod(p)*mod(q). If you get r = 0, please try another random value of k and compute again for r
except 0.
Calculate
s=(k^(-1)*(H(m)+xr))*mod(q). If you get s = 0, please try another random value of k and compute again
for s except 0.
The signature is defined by two key elements (r,s). Also, key elements k and r are used to create a
new message. Nevertheless, computing r with modular exponential process is a very expensive
process and computed before the message is known. Computation is done with the help of the
Euclidean algorithm and Fermat's little theorem.
4. Signature Verification
You use the same hash function (H#) to generate the digest h.
You then pass this digest off to the verification function, which needs other variables as parameters
too.
Compute the value of w such that: s*w mod q = 1
Calculate the value of u1 from the formula, u1 = h*w mod q
Calculate the value of u2 from the formula, u2 = r*w mod q
The final verification component v is calculated as v = [((gu1 . yu2) mod p) mod q].
It compares the value of v to the value of r received in the bundle.
If it matches, the signature verification is complete.
Having understood the functionality of the DSA Algorithm, you must know the advantages this
algorithm offers over alternative standards like the RSA algorithm.
Correctness of the Algorithm
The correctness of the algorithm can be computed using following signature schemes.
s=(k^(-1)*(H(m)+xr))*mod(q)
k=H(m)*s^(-1)+x*r*s^(-1)
= H(m)*w+x*r*w*mod(q)
g^k=[g^(H(m)*w)]×[g^(xrw)]
=[g^(H(m)*w)]×[y^(rw)]
=g^(u1)*y^(u2)*mod(p)
Thus, the correctness of algorithm for DSA is
r=(g^(k)*mod(p))mod(q) =[g^(u1)*y^(u2)*mod(p)]*[mod(q)]
r =v
Sensitivity
1. In DSA, the random values of signature key element k are critical that violating it may reveal the
entire privacy to the attackers. Sometimes, using the same value for the signature key element and
losing a few bits of k might be enough to reveal the private key x to attackers.
2. An attack can be prevented only if a new random value of k is calculated for every different signature
value. Thus, it is necessary to have the different value of k for every different H(m) and unpredictable
in order to keep the private key x secret from attackers.
How Does DSA Work?
DSA stands for Digital Signature Algorithm. It is a cryptographic algorithm used to generate digital
signatures, authenticate the sender of a digital message, and prevent message tampering.
DSA works by having two keys: a private key owned by the sender and a public key held by the
receiver.
The sender uses their private key to generate a signature for the message, which is then sent along
with it.
Then, the message receiver uses the sender's public key to verify that the signature is valid and that
the message has not been tampered with.
The verification process is done using unique algorithms that allow the receiver to validate the
signature without having access to the sender's private key.