CSC 172辅导 、Java/C++程序设计讲解
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