PART ONE:Randomness and Cryptographic Security

1)
(Parallelism)An attacker performs three attacks of 2^128 operations each on three different days. On the first day, the attacker only uses one processor to perform those 2^128 operations (sequentially dependent operations). On the second day, the attacker uses 2^20 processors to perform such 2^128 operations (parallel processing operations, e.g., each processor does the same number of operations). And the third day, the attacker uses 2^34 processors to perform also 2^128 operations.

- How much faster will the attacker complete the attacks on Day 2? And on Day 3?

- How many operations does each processor perform on Day 2? And on Day 3?

Pleaseshow all the work/calculations.Hint:Day 2 and Day 3 are independent of each other.

2)We have a cryptosystem that uses a 192-bit key.If we are able to try 1024 192-bit keys every day, how many days would it take us to check every possible key?(For example, this would be 4 2-bit keys: 00, 01, 10, 11)

Hint: The first thing you should do is calculate the total number of possible keys. We have seen that before and talked about it, e.g., if my key is 3-bits long, then I can obtain 8 different keys.

3)This code prints random 16 bytes in two different formats: Raw bytes and URL-Safe (with characters that we actually use, more readable).

·First, I imported the modulesecretsfor generating cryptographically strong random numbers.

·Line 3 can be omitted since I wanted to use it for something else.

·Next, I declared the variableAES_key_lengthwhich contains the number ofbytesmy random key will have.

·After that, I declared
secret_key

(you can name it differently)and assigned
secrets.token_bytes(AES_key_lenght)

to it; and
secret_key1

(you can name it differently)and assigned
secrets.token_urlsafe(AES_key_lenght)

to it.

·Note:
secrets.
is needed before most of the functions in the secrets module. The functions I used are two:
token_bytes(...)
and
token_urlsafe(...)
.

·Lastly, I just print two sentences to show the contents of mysecret_keyand mysecret_key1variables.

In thislink(Links to an external site.), there is one more function:token_hex.

You need to implement the token_hex function to output random
256-bits
keys in the three different formats (2 of them are already done)

Hint: To do this, you will need to create one more variable between lines 7 and 8 (it can besecret_key2), and instead of token_bytes or token_urlsafe, use the token_hex function. Then, you will need to change the number 16 (bytes) since we want to have256 bits(remember that 16 means16 bytes.1 byte = 8 bits). Lastly, you just need to print yoursecret_key2at the end of the code.

In summary, you will need to add two lines to the program given and change the number 16.

PART TWO: Stream Ciphers

Show all the calculationsas is shown in the lecture/book.

1) Consider a 5-bit FSR whose feedback functionfXORs all 5 bits together.Show 2 cycles of that FSR: one that starts with 00001, and one that starts with 11110 of that FSR.

2) Consider a 3-bit LFSR whose feedback polynomial is X^3 + X^2 + 1. Show all the cycles of that LFSR.

Hint:
The bits in the LFSR state that influence the input are called taps. The "one" in the polynomial doesnotcorrespond to a tap – it corresponds to the input to the first bit (i.e. x^0, which is equivalent to 1). So, in the assignment, there are only two taps (in other words, you just need to XOR two bits each time)