1)(Parallelism) An attacker performs three attacks of 2^120 operations each on three different days. On the first day, the attacker only uses one processor to perform those 2^120 operations (sequentially dependent operations). On the second day, the attacker uses 2^32 processors to perform such 2^120 operations (parallel processing operations, e.g., each processor does the same number of operations). And the third day, the attacker uses 2^42 processors to perform also 2^120 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?
Please show all the work/calculations.
Hint: Day 2 and Day 3 are independent of each other. Same as the example we did in class
2) We have a cryptosystem that uses a 256-bit key. If we are able to try 512 256-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 module secrets for generating cryptographically strong random numbers.
- Line 3 can be omitted since I wanted to use it for something else.
- Next, I declared the variable AES_key_length which contains the number of bytes my 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 my secret_key and my secret_key1 variables.
In this linkLinks to an external site., there is one more function: token_hex.
You need to implement the token_hex function to output random 192-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 be secret_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 have 192 bits (remember that 16 means 16 bytes. 1 byte = 8 bits). Lastly, you just need to print your secret_key2 at the end of the code.
In summary, you will need to add two lines to the program given and change the number 16.
