This is a Cryptography question. Thanks in advance!! Creating a digital certific

Question

This is a Cryptography question. Thanks in advance!!

Creating a digital certificate for Alice:

There will be three parties: Trent, Alice, and Bob. We will not build parts that just repeat other parts, but will have at least “one of each” that’s interesting.

You will create RSA systems for Trent and Alice. (You do not need to check that Trent and Alice will have different n’s, as in a “real” RSA systems this guaranteed probabilistically.)

Print a line with the line number shown on the left and below that line, list the following for Trent, both as integers and as sequences of bits: p, q, n, e, d. See the sample output files for reference.

Trent’s public key will be known to all (Trent, Alice, and Bob). Trent will issue a digital certificate to Alice. The digital certificate will consist of two parts:
1. the pair r = (Alice, public-key-of-Alice)
2. the signature s = Trent’s-signature-on-R

Let us discuss the the formats and what needs to be done. The format for r will be as follows.Its length will be 14 bytes, defined as:

1. Bytes 1–6: The string Alice padded to the left with blanks. Here and elsewhere this means spaces. We assume that a name will fit in 6 bytes, but Alice only needs 5.

2. Bytes 7–10: n, padded with leading 0 bits, as necessary, so it is a standard integer stored in 32 bits. (Note, that n could have been stored in 2 bytes, thus mimicking closer what happens in reality when n is big, but let’s not worry about this.)

3. Bytes 11–14: e, padded with leading 0 bits, as necessary, so it is a standard integer stored in 32 bits.

The signature s is h(r) decrypted with Trent’s private key (using fast exponentiation).

Let’s talk about h, the one-way hash function. It will be 1 byte long. You will partition r into bytes and compute their exclusive or. The resulting 1 byte will be your hash. It is simpler to store it as integer, so pad it with leading 0 bits. Therefore, h(r) and s will be stored using 32 bits.

Print a line with the line number shown on the left and below that line, list the following as sequences of bits: r, h(r), s. See the sample output files for reference.
Print a line with the line number shown on the left and below that line, list the following as integers: h(r),s. See the sample output files for reference.

Alice is given the certificate. We will skip the step that Alice takes to confirm that she got a valid signature as signature checking needs to be done by Bob anyway, so we do not need to practice doing this here.
--------------------------------------------------------------------------------
Alice authenticates herself to Bob:

Bob is going to have Alice authenticated. He gets her certificate. We skip the checking of whether this certificate was signed by Trent, and checking that the format is right, etc.
Alice and Bob will cooperatively pick a random number u, big, but smaller than n. They will do it as follows. Consider the bits of n, n = n_31n_30 . . . n_1n_0.
There are going to be some leading 0 bits as n really fits in 2 bytes. So let k be such that n_31=···n_k+1=0,but n_k=1.
Let u = u_31u_30 …u_1u_0. For k defined as above, set u_31 = ··· = u_k = 0 and u_k-1 = 1. Choose u_k-2, . . . , u_0 randomly, bit by bit.
Example: n = 10057, which in bits is 00000000000000000010011101001001.
From the value of n we see that k = 13. Therefore, u will be of the form
00000000000000000001xxxxxxxxxxxx where all the x’s are random bits, and 4096<u<8191.

Alice will pick the first [length(x)/2] bits and Bob will pick the last [length(x)/2] bits. Alice sends her bits to Bob and Bob sends his bits to Alice.
In this way they both know u. As discussed in class, we do not want only one of them to create the challenge. But you do not have to bother with these exchanges, and just produce the needed u.
Print a line with the line number shown on the left and below that line, list the following as integers: k, u. See the sample output files for reference.

Print a line with the line number shown on the left and below that line, list the following as a sequence of bits: u. See the sample output files for reference.

Alice will compute h(u) and using fast exponentiation decrypt it with her
private key getting v. She will send v to Bob. Bob will encrypt v with Alice’s
public key using fast exponentiation and check whether it is indeed h(u). If it
is, Bob knows that he is talking to somebody who knows Alice’s private key.

Print a line with the line number shown on the left and below that line, list the following as integers and as sequences of bits: u, h(u), v = D_{RSA}(d, h(u)) , E_{RSA}(e, v). (e and d are, as computed before, Alice’s.). See the sample output files for reference.

Print a line with the line number shown on the left and below that line, show a trace of your computation of E(e,v) (using fast exponentiation, of course), exactly like the trace provided in the sample output files. See the sample output files for reference.

Explanation / Answer

Answer:

The art of protecting information by transforming it into an unreadable format, called cipher text. Only those who possess a secret key can decipher the message into plain text. Encrypted messages can sometimes be broken by cryptanalysis, also called codebreaking, although modern cryptography techniques are virtually unbreakable.As the Internet and other forms of electronic communication become more prevalent, electronic security is becoming increasingly important. Cryptography is used to protect e-mail messages, credit card information, and corporate data. One of the most popular cryptography systems used on the Internet is Pretty Good Privacy because it's effective and free.Cryptography systems can be broadly classified into symmetric-key systems that use a single key that both the sender and recipient have, and public-keysystems that use two keys, a public key known to everyone and a private key that only the recipient of messages uses.

Related Questions

Navigate

• Browse (All)
• Browse T
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.