Unix - Program 1
Create a script in C Shell that can be executed only from a specific terminal. This is done for security purposes. For example, a superuser may write scripts that can only be executed from his or her office and nowhere else.
Preparation:
None
Script
• Script Name: security.scr
• Arguments: None
• Body Section: Create a script that prints a friendly message. However, the script can be executed only from one terminal. You can use the name of the terminal you are using when you write the script (Note: All of our terminals are “soft” – so this assignment doesn’t make sense – just go ahead and use any pts numbered terminal). If somebody uses the script from a terminal that is not authorized, the script exits immediately. Hint: Use the tty command to find the current terminal. Think of this script as a front-end for scripts that need to executed on a secure terminal. This would mean that the friendly message would eventually be replaced with the body of the script.

Testing the Script
• Test the script with one argument (to see if it fails).
• Test the script from the right terminal.
• Test the script from a terminal that should not work.

Sample Script Header:
#!/bin/csh
#AUTHOR: your name
#Class:       CS2080.001 (or 002)
#TITLE:       short description
#DATE DUE: date
#DESCRIPTION:    Checks blah blah … long description
#
#EXIT VALUES
#                      0    if successfully completed
#                   10    incorrect number of arguments
#                   20    one or more files does not exist
#                   30    …..

Unix - Program 2
Write a script to backup a list of files in C shell
Preparation:
• Create a file and type in the list of files (in your directory) that you want to backup.
• Create a directory in which you will store the backed-up files.
Script
• Script Name: backup.txt
• Arguments: A filename and directory. The filename holds the list of the files that should be backed-up. The directory is where the backed-up files should be stored.
• Validation: The minimum validation requirements are:
o Ensure that exactly two arguments are entered.
o Check that the first argument is the name of a file that exists.
o Check that the second argument is the name of a directory that exists.
• Body Section: Create backup files for all the files listed in the first argument. The backup files should have the same name as the original file with the extension .bak. They should be copied to the directory given as the second argument. the backup MUST be done inside a loop. Also, the command (line) that copies the file needs to place the copy in the given directory and rename it to .bak.
Testing the Script
• Test the script with no arguments
• Test the script with one argument.
• Test the script with three arguments.
• Test the script with two arguments – the first not being the name of a file.
• Test the script with two arguments – the second being the name of a file, not a directory.
• Test the script with the name of the file and directory that you created.

Testing the Effect of the Script
• Check the contents of the directory to be sure the files were copied.

Sample Script Header:
#!/bin/csh
#AUTHOR: your name
#CLASS:       CS2080.001 (or 002)
#TASK:       Short description
#DATE DUE: date
#DESCRIPTION:    Reads files by line and …Long description
#
#EXIT VALUES
#                      0    if successfully completed
#                   10    incorrect number of arguments
#                   20    one or more files does not exits
#                   30    …..

Assembly - Program 3
In this assignment, we will explore symmetric key cryptography. You will have to write three methods: Hash, Encrypt and Decrypt.

Hash
This method hashes a 32-bit integer to obtain another 32-bit value. Use the same algorithm as in Program 2. However, the input is not a string, but an integer. This integer is in $a0. The hashed value you return will be in $v0. To obtain the first byte (of four) in your hashing process, you simply need to mask all the bits except the 8 on the right. You can do this with an andi instruction. To obtain the second byte in the four-byte integer, you have to shift the value right 8 bits (use the srl instruction) before masking. For the third byte, shift right 16 bits, then mask. And so on. So, four times you will multiply the contents of $v0 by 31 and add the byte you isolate from $a0.

Encrypt
strPlaintext is the string you will encrypt. It happens to be 29 characters (bytes) long. Since our key is 4 bytes long, the output buffer for the encryption needs to be 32 bytes long, the next highest multiple of four. Symmetric key encryption uses the same key to encrypt and decrypt the message. This is done with the xor instruction. The fundamental insight here is that c = m xor k and m = c xor k where m is the plain text message, c is the cipher text message and k is the key. So to go from the plain text to cipher text, we simply xor with the key. But the key is only four bytes long. We can only xor four bytes at a time. We could simply re-use the same key each four bytes. Unfortunately, using the same key over and over would subject the key to cryptanalysis. So once we xor the first four bytes of the message with the key, we obtain the hash of the key and use that for the second four bytes. We hash that value again for the next four bytes of the message and so on. That’s why the resultant cipher text is a multiple of four bytes. Thus, the basic process is xor the first four bytes of the message with the key, hash the key, xor the second four bytes of the message with the new key, then hash the key again, and so on. When Encrypt is called, the address of the plain text string is in $a0. The value of the key is in $a1, The address of the cipher text buffer is in $a2, and the number of 4-byte words to be encrypted is in $a3.

Decrypt
This simply undoes Encrypt. You simply proceed through the cipher text buffer, four bytes at a time, and xor with the key. The first time you use the real key. Subsequent iterations use the hash of the key from the previous iteration. When Decrypt is called, $a0 contains the address of the cipher text buffer, the key is in $a1, the address of the plain text buffer is in $a2, and $a3 contains the number of words to decrypt.

Worth noting is that both the Encrypt and Decrypt routines call Hash. This means that you need to preserve certain register values. Thus, both Encrypt and Decrypt should begin with pushing values onto the stack. The reverse should happen at the end of the routines.

Unix - Program 1 Create a script in C Shell that can be executed o...