6. Consider the following simplified version of the CFB mode. The plaintext is broken into 32-bit pieces: P = [P₁, P2, ,], where each P; has 32 bits, rather than the 8 bits used in CFB. Encryption proceeds as follows. An initial 64-bit X₁ is chosen. Then for j = 1,2,..., the following is performed: CjPjL32 (Ek (Xj)) Xj+1 = R32(Xj)||C; where L32(X) denotes the 32 leftmost bits of X, R32 (X) denotes the rightmost 32 bits of X, and XY denotes the string obtained by writing X followed by Y. Find the decryption algorithm.

6. Consider the following simplified version of the CFB mode. The plaintext is broken into 32-bit pieces: P = [P₁, P2, ,], where each P; has 32 bits, rather than the 8 bits used in CFB. Encryption proceeds as follows. An initial 64-bit X₁ is chosen. Then for j = 1,2,..., the following is performed: CjPjL32 (Ek (Xj)) Xj+1 = R32(Xj)||C; where L32(X) denotes the 32 leftmost bits of X, R32 (X) denotes the rightmost 32 bits of X, and XY denotes the string obtained by writing X followed by Y. Find the decryption algorithm.

Systems Architecture

7th Edition

ISBN:9781305080195

Author:Stephen D. Burd

Publisher:Stephen D. Burd

Chapter8: Data And Network Communication Technology

Section: Chapter Questions

Problem 41VE

See similar textbooks

Similar questions

Consider a simple system with 8-bit block size. Assume the encryption (and decryption) to be a simple XOR of the key with the input. In other words, to encrypt x with k we simply perform x⊕k giving y. Similarly, to decrypt y, we perform y⊕k giving x. You are given the following 16-bit input “F5C6” in hexadecimal. You are provided IV as “8C” in hexadecimal. The key to be used (where appropriate) is “49” in hexadecimal. Compute the encrypted output with the following methods. Express your final answer, for each of them, as 4 hexadecimal characters so it is easy to read. A. Using ECB B. Using CBC C. Using OFB D. Using CFB
Asap
Implement the following function F(x,y,z) using a decoder. This function will return 1 if the value is divisible by Four otherwise it will return zero. asap pls.
***Please use the 16-bit input of F5C6 and NOT the 16-bit F0F0. I've been trying to figure this out for awhile and all explanations have used F0F0, not F5C6***Consider a simple system with 8-bit block size. Assume the encryption (and decryption) to be a simple XOR of the key with the input. In other words, to encrypt x with k we simply perform x⊕k giving y. Similarly, to decrypt y, we perform y⊕k giving x. You are given the following 16-bit input “F5C6” in hexadecimal. You are provided IV as “8C” in hexadecimal. The key to be used (where appropriate) is “49” in hexadecimal. Compute the encrypted output with the following methods. Express your final answer, for each of them, as 4 hexadecimal characters so it is easy to read. A. Using ECB B. Using CBC C. Using OFB D. Using CFB
Implementing AES Implement (almost) the first round of AES with a 128-bit key. Given a 128-bit plaintext and a 128-bit key, this involves: Performing a bitwise XOR with the plaintext and the key Applying byte substitution for each byte in the state Applying shift rows on the state table rows Applying mix columns on the state table columns Output the state table at this point. The "almost" above means that you don't have to perform the XOR with the state and the first sub-key. Please name the program AESEncryptRound.java or aesencryptround.py. You may hard code the inputs. Please use the following inputs, which are the same as given in Appendix B of the FIPS197 document: plaintext = 0x3243f6a8885a308d313198a2e0370734 key = 0x2b7e151628aed2a6abf7158809cf4f3c The byte substitution, multiply-by-2, an multiply-by-3 tables are available at AEStables.txt. Each is given as a list where the ith entry is the value of applying the given operation to i. Please print the state table after each…
Using C programming language: A Transposition Cipher A very simple transposition cipher encrypt(S, N) can be described by the following rules: If the length of S is 1 or 2, then encrypt(S, N) is S. If S is a string of N characters s1 s2 s3... sN and k = N/2, then encrypt(S)= encrypt(sk sk−1... s2 s1 ,K)+ encrypt(sN sN−1... sk+1 ,N - K) where + indicates string concatenation. For example, encrypt("Ok", 2) = "Ok" and encrypt("12345678", 8) = "34127856". Write a program to implement this cipher. The input is a file that is guaranteed to have less then 2048 characters. Code structure might look like this: #define MAX_SIZE 2048char text_buffer[MAX_SIZE];int main(){ // read file into text_buffer encrypt(text_buffer, n); // print out text_buffer return 0;}
Question KNh Similar to Problem 3.4 in the textbook(• C. Paar and J. Pelzl, Understanding Cryptography, Springer, 2009. ISBN 978-3-642-04100-6.): What is the output of the a round of the DES f-function when the 48-bit output of the expansion function and the 48-bit round key are both all ones? Write first (in binary) the outputs of the S-boxes:S1(0)=S2(0)=S3(0)=S4(0)=S5(0)=S6(0)=S7(0)=S8(0)=Next, write (in Hexadecimal) the output of the P permutation withing the f-function: ( )
You are given two bit locations, i and j, together with the 32-bit values N and M. To insert M into N, provide a procedure that starts M at bit j and finishes it at bit i. It is safe to presume that all of M can fit in the bits j through i. In other words, you may infer that there are at least 5 bits between j and i if M = 10011. M could not completely fit between bit 3 and bit 2, thus you would not, for instance, have j = 3 and i = 2.
In this problem, you will design a circuit that encrypts (plaintext to cipher) and decrypts (cipher to plaintext) ASCII characters. The relationship between the plaintext character and cipher character is shown in the table below: plaintext character cipher character 1-? A-O P-Z space t-~ 0 In this table, the "0" and "1" refer to the characters "0" and "1", not the numerical values. Additionally, the circuit only needs to account for character listed in the table. The circuit has nine bits of input: • d = d7... do: an eight-bit number that is the binary representation of the input ASCII character • e: a single bit indicating if the circuit should encrypt (e = 1) or decrypt (e = 0) the given character The circuit has eight bits of output: • r = r7...ro: an eight-bit number that is the binary representation of the output ASCII character Draw the implementation of the circuit. The circuit does not have to be transistor-minimal; you are encouraged to use various combinational circuitry to…
p T Note: The notation from this problem is from Understanding Cryptography by Paar and Pelzl. Suppose you have an LFSR with 6 state bits. The first 12 bits of output produced by this LFSR are 100011011000 = s0 $1 $2 S3 S4 S5 S6 87 Sg S9 S10 S11 - The first bit produced is the leftmost bit and the bit most recently produced is the rightmost bit. a) What is the initial state of the LFSR? Please enter your answer as unspaced binary digits (e.g. 010101 to represent S5 = 0, s4 = 1, 83 = 0, s2 = 1, s1 = 0, so = 1). %3D b) What are the tap bits of the LFSR? Please enter your answer as unspaced binary digits (e.g. 010101 to represent P5 = 0, p4 = 1, pP3 = 0, p2 = 1, p1 = 0, po = 1).
Create a MIPS assembly program using MARS to do RSA encryption/decryption. Get a numeric message from the user and encrypt it. Also, get a numeric message from the user and decrypt it. An RSA public key consists of a pair of numbers (n, e), and the message m is encrypted to a ciphertext c by calculating c = me (mod n). The RSA private key consists of a pair of numbers (n, d), and a ciphertext c is decrypted by calculating m = cd (mod n). For this, use n=21733, e=257, d=1403. Note that since me and cd can get rather large (hundreds or thousands of digits for our examples), use the following pseudocode to handle encryption and decryption: doRSA( n, exp, msg ) cmsg = msg Initialize ciphertext, requires odd exponent mpow = msg message to the power 1, 2, 4, 8, 16, … tempexp = exp temporary exponent while ( tempexp > 1 ) mpow = ( mpow * mpow ) % n square the message tempexp = tempexp / 2 update the power if ( tempexp % 2 == 1 ) 1 bit in the binary representation of e? cmsg = ( cmsg…
In this problem we will work through a round of DES. For notational simplicity, assume it is the first round. Please enter all answers as strings of 0's and 1's. The input is the 64 bit block 0000000000000010000000000000001000000100000001000100000000000000 Suppose that the subkey for the current round is this 48 bit number: 000000000000000001000000000000000000000000000000 What does the 64 bit state look like after the IP transformation is applied to the input? 00000000000110000100000000000000 Now find Lo and Ro, the left and right halves of the state. Lo 01000000010000000000000000010000 = Ro=00000000000000100000000000000000 What is the result of applying the expansion box to R₁? E(Ro) = 00000000000000100000000000000000 What is the result of XORing the subkey with E(Ro)? k₁ E(Ro) = 00000000000000100000000000000000 We now apply the S-box transformation. S(k₁ E(Ro)) = 11011000110110001101111110111100 Finally we apply the permutation box to complete the function f. f(Ro) = P(S(k₁ + E(Ro)))…