CSC 172代写、Java/C++程序设计代做

日期：2024-03-18 09:19

CSC 172 – Project 1

? You may work on and submit your project individually or in groups of 2 students.

? If you work in a group you will have to prepare an extended README file to specify

who wrote each part of the code for maintaining clarity and transparency within the

group project.

? You are only allowed to cooperate with your group members, and you are not permitted

to share your solution with other students in any way.

Task

You will implement a cipher specified below using Java programming language. It shall

encrypt/decrypt text files including plaintext/ciphertext.

Background

1. Encryption is the process of encoding information or data in such a way that only

authorized parties can access it. This is typically done using algorithms and secret

keys to transform the original data into an unintelligible form known as ciphertext.

2. Plaintext refers to the original, unencrypted data or message that is intended to be

kept confidential.

3. Ciphertext refers to the encrypted form of data or information that has undergone

encryption.

Working with files

To encrypt content of a text file you have to:

? Read the file: open the file you want to encrypt and read its contents into memory.

? Convert to binary.

? Encrypt the data: use the presented encryption algorithm and the user secret key to

encrypt the data read from the file.

? Do NOT convert back to characters.

? Write encrypted data to file: save the encrypted data to a new file.

To decrypt content of a text file you have to:

1

? Read the file: open the file you want to decrypt and read its contents into memory

(content should be just long sequence of zeros and ones).

? Decrypt the data: use the presented decryption algorithm and the user secret key to

encrypt the data read from the file.

? Convert to characters.

? Write decrypted data to file: save the encrypted data to a new file.

1 Algorithm Description

The algorithm encrypts fixed number of bits only (64 bits). To encrypt longer input use the

simple ECB (Electronic Codebook) mode. Here’s how it works:

? Divide the data into blocks: the plaintext data is divided into fixed-size blocks of 64

bits.

? Apply encryption to each block independently: each block of plaintext is encrypted

independently using the same secret key and encryption algorithm. The same key is

used for each block.

? Output the encrypted blocks: the resulting ciphertext blocks are concatenated together

to form the complete ciphertext.

? If the last block doesn’t have enough bits, it needs to be padded to meet the required

block size. This process is known as padding. Use zero padding: append zero bits

to the end of the block until it reaches the required size. (Do not worry about extra

characters at the end when you decrypt.)

Include methods to encrypt/decrypt a single block of plaintext/ciphertext that implements the following symmetric-key encryption algorithm:

2

Your output shall be a block of 64 zeros and ones. (Do not represent the output block in a

Hex notation. If you do that you get -10%.) Encryption and decryption are almost the

same, but for decryption you need to use subkeys in a reverse order: k10, k9, ...k1

3

1. Input Splitting: The plaintext block of 64 bits is divided into two halves of 32 bits.

Let’s denote these halves as L0 and R0.

2. Round Function Application: In each round, a round function f is applied to one

half of the data, typically the right half Ri

, using the round key ki of 32 bits. The

result of the function is then XORed with the other half Li

.

Li+1 = Ri

Ri+1 = Li ⊕ f(Ri

, ki)

3. Swapping: After each round, the halves are swapped so that the left half becomes

the right half, and vice versa.

4. Iteration: Steps 2 and 3 are repeated 10 times.

5. Output Concatenation: After all rounds are completed, the final output consists of

the two halves (L10 and R10) concatenated together. This forms the ciphertext.

1.1 The f - function

The f - function (round function) works as follows:

1. XOR gate: The 32 input bits are XORed with the round key ki

.

2. Splitting: The 32 bits are divided into four pieces of 8 bits.

4

3. S-box: For each piece of 8 bits the output of a S-box is computed (’looked up in the

S table’).

4. Output Concatenation: All four pieces are concatenated together to form 32 bits.

5. Permutation: 32 bits are permuted using permutation P.

S is a substitution box transformation (Rijndael S-box):

The table of the S-box, stated in hexadecimal for compactness. Permutation P is given by

the table:

See the last page if clarification about S and P is needed.

5

1.2 Computing subkeys

The round keys of 32 bits (subkeys ki) are derived from the input key of 56 bits by means

of the key schedule (total of 10 subkeys) using the following schedule:

1. Splitting: The main key k of 56 bits is divided into two halves of 28 bits. Let’s denote

these halves as C0 and D0.

2. Transformation Function: In each round, a left shift by 1 function LS1 is applied

separately to both half’s of the data, typically the right half Ri

, using the round key

ki of 32 bits. The result of the function is then XORed with the other half Li

.

Ci+1 = LS1(Ci)

Di+1 = LS1(Di)

3. Concatenation: In each round two halves (Ci and Di) are concatenated together.

The first (left most) 32 bits forms the round subkey ki

.

4. Iteration: Steps 2 and 3 are repeated 10 times.

6

1.3 Required methods

Your implementation must include the following methods:

? Custom xorIt(binary1, binary2)

? Custom shiftIt(binaryInput)

? Custom permuteIt(binaryInput)

? Custom SubstitutionS(binaryInput)

? functionF(rightHalf, subkey)

? encryptBlock(block, inputKey),

? decryptBlock(block, inputKey),

? encryption(longBinaryInput, inputKey),

? decryption(longBinaryInput, inputKey),

? keyScheduleTransform(inputKey),

? runTests()

? You can have additional helper functions. Custom means you can NOT use

ready methods and must write your own methods.

1.4 Build-in tests

The runTests() mathod shall be invoked when user runs the program and it shall print

output for the following test cases:

? encryptBloc(all ones, all ones)

? encryptBloc(all zeros, all ones)

? encryptBloc(all zeros, zeros)

? encryptBloc(block,input key), where:

block = 1100110010000000000001110101111100010001100101111010001001001100

input key = all zeros

? decryptBlock(all ones, all ones)

? decryptBlock(all zeros, all ones)

7

? decryptBlock(all zeros, zeros)

? decryptBlock(block,input key), where:

block = 0101011010001110111001000111100001001110010001100110000011110101

input key = all ones

? decryptBlock(block,input key), where:

block = 0011000101110111011100100101001001001101011010100110011111010111

input key = all zeros

When running the program

When the user runs the program, it should print output for the test cases from section 1.4.

The program should then prompt the user to choose whether they want to encrypt or decrypt

and specify the filename to process. Additionally, the program should ask for a filename to

save the output, and an appropriate file should be created for this purpose.

Running Tests:

Output for: encryption(all ones, all ones)

0101011010001110111001000111100001001110010001100110000011110101

Output for: encryption(all zeros, all ones)

1100111010001000100011011010110110110010100101011001100000101000

Output for: encryption(all zeros, all zeros)

1010100101110001000110111000011110110001101110011001111100001010

Output for: encryption(block,all zeros), where:

block = 1100110010000000000001110101111100010001100101111010001001001100

0010101110011011010001010111000010110110101011111010000101100101

Output for: decryption(all ones, all ones)

0100111001000110011000001111010101010110100011101110010001111000

Output for: decryption(all zeros, all ones)

1011001010010101100110000010100011001110100010001000110110101101

Output for: decryption(all zeros, all zeros)

1011000110111001100111110000101010101001011100010001101110000111

Output for: decryption(block,all ones), where:

block = 0101011010001110111001000111100001001110010001100110000011110101

1111111111111111111111111111111111111111111111111111111111111111

Output for: decryption(block,all zeros), where:

block = 0011000101110111011100100101001001001101011010100110011111010111

1111111111111111111111111111111111111111111111111111111111111111

Do you want to encrypt or decrypt (E/D): E

Filename: data.txt

Secret key: 10101101011101110101010101011100010110101011100010101010

8

Output file: data1.txt

Submission Requirements

Zip (archive) all the project source files and a README file and save it as a Project1LastName.zip

file. Include your LastName (+partner) in the filename. Upload the file to the appropriate

folder on Gradescope. Your README file should include name of the members of the team

and any specific instruction which is useful for the project. It should also include all the features (including additional features) that you have implemented. Make sure all your source

files are properly commented so that user can browse your code without getting lost.

2 Grading

The rubric for this assignment is available through Gradescope. Your solution will be tested

with private test cases.

0 points if the program doesn’t compile. No points for the rest. Grading complete.

2.1 Important note about Academic Honesty

If some of the tasks are challenging or not for you, feel free to discuss with others but all

discussion have to be on high level without writing code or pseudocode. Once you sit down

and start coding, all the code you write should be your own . Using ready code from other

sources (internet, friends, chatGPT etc.) will be considered as a violation of the academic

honesty. After submitting your work, you should be able to explain your code in details, if

so requested by lab TAs or by the instructor. Your initial points may be reduced, if unable

to answer questions on your submitted work.

3 Hints

? Text file sbox.txt contains a constant - S- box look up table that you can use.

? S- box example:

– Let’s say we want to compute the substitution for the byte 53 (in binary 01010011).

– We’ll first convert 53 to its row and column indices.

– The first hex digit (5) represents the row index.

– The second hex digit (3) represents the column index.

– So, for 53, the row index is 5 and the column index is 3.

– Now, we’ll look up the value in the S-box using these indices.

9

– The value at row 5 and column 3 in the S-Box is ed (in binary 11101101).

? Permutation table example: Consider table (3x3):

Sample input: 101111000

Output after permutation: 001111010

– The permutation table rearranges the elements of the input according to the

specified positions.

– Each number in the permutation table represents the position of the corresponding

element in the input.

– For example, the element at position 1 of the input (value 1) becomes the element

at position 4 of the output.

– Similarly, the element at position 9 of the input (value 0) becomes the element at

position 1 of the output.

Sample input 2: 111000111

Output after permutation 2: 111100101

10