The Laws of Cryptography

The Laws of Cryptography:
List of Projects

by Neal R. Wagner

Ground Rules for Projects

Copying: You must document any code or other reference material that you use in your project. Any team deliberately submitting code for a project (even modified code for part of the project) and deliberately concealing the source of the code will receive a zero grade for this part of the course (or if they refuse the zero, will have to go through the ordinary UTSA channels for academic dishonesty).
You are allowed to use code and other materials that you have not written yourself as long as you document the sources and admit to the use. In this way you might add to or expand on someone else's work.
Submitting code that you didn't write as if it were your own work is the one unacceptable act in this course.
Standards for grading projects: The project ideas listed below vary greatly in difficulty -- from too easy for a reasonable project to too hard to finish by the end of the semester. I will evaluate your project based on the amount of effort expended and the quality of the final result. (The size of the group working on the project will also influence the final evaluation.) Just finishing one of the items in this list does not guarentee a good grade on the project; in many cases the item is listed to get you started. If you finish some project with little work and with little to show for it, then you need to expand the scope of the project, perhaps with help from me.
In many cases I want to encourage you to tackle a hard project, one without a guarentee of final success. If you do good work for the project and produce evidence of your effort, you can get a good grade even if you do not finish the final program or the final program does not work according to specifications. (Projects for a course are different from the environment in the ``real'' world, because absolute requirements are somewhat artificial. If you try something hard, you cannot be sure of success. People who say ``failure is not an option'' may hype themselves up, but they are fools if they have no contingency plans for setbacks.)
Programming language for projects: Normally you should code in Java. C or C++ is also acceptable, but in that case you should let me know. It is conceivable that I might approve another language (such as Perl), but then you must inform me.
man page: For many of these projects, you can create a Unix-style man page that describes your software and how to use it.

Possible Projects

I. Using the Advanced Encryption Standard (AES)

Encrypted files: The AES implementation that I have written takes an array of bytes as input and produces and array of bytes as output. I have supplied I/O code to read/write two hex characters for each byte of input/output. You could arrange to read/write ASCII plaintext files and read/write binary ciphertext files. One problem is the key, which could be constructed from an input ASCII password. In this way you can write a program similar to the Unix crypt that allows a user to encrypt files.
Encryption/decryption as a filter: Essentially the same as the previous item, add code so that the AES can be used as a filter (in Unix terms). Thus you pipe a file through an encrypt routine and later pipe the encrypted file through a decrypt routine. As above there needs to be some way to specify the key.
CBC mode for AES: Implement the CBC mode for the AES.
AES for a checksum: Use the CBC mode to allow AES to function as a 128-bit checksum, as is discussed in the section describing block ciphers (using the last encrypted block). Here there is no need for secrecy, so the key could be anything, even all 0 bits.
AES for a cryptographically secure checksum: Use the CBC mode to allow AES to function as a 128-bit cryptographically secure checksum. Here there needs to be some way to supply a secret key.

II. Other Block Ciphers

Implement a block cipher: Implement one of the various available block ciphers. The difficulty depends on the particular cipher, but any of them would be fairly hard. Appearing in the Handbook of Applied Cryptography are the ciphers DES, FEAL, IDEA, SAFER, and RC5 (which is presumably the easiest).

III. Stream Ciphers

Implement SEAL: Implement the stream cipher SEAL (or SEAL 2.0), as described in the Handbook of Applied Cryptography.

IV. Public-key Cryptography

Implement RSA: Implement a ``toy'' version of the RSA cryptosystem. Here ``toy'' means that the implementation is limited to the size of a long in Java, so that this system would not remotely have large enough keys to be secure. Nevertheless, implementing it is a useful exercise in discovering how RSA works. (The implementation in the text proper uses the java BigInteger class, which directly implements almost all the necessary functions for RSA using arbitrary precision arithmetic.)

V. Random Number Generators

Traditional RNG: Implement one of the traditional RNGs.
Perfect RNG: Implement one of the perfect RNGs based on RSA.
Statistical testing of a RNG: Implement a statistical test for a RNG. The test called ``Maurer's universal statistical test'' in the Handbook of Applied Cryptography might be a good example. Test either a ``perfect'' RNG or the RNG based on chaos theory from the notes.

VI. Hamming Code

General Hamming Code: Implement a ``reference'' version of the Hamming code, to examine its properties.
Practical Hamming Code: Implement a ``practical'' Hamming code for use with text files. Use the version with 64 bits altogether, including 7 check bits and 57 data bits. (In this way, for each 7 text characters, one needs to use 1 extra byte to produce a binary file that has single error correction, double error detection in each 7 bytes of text, or each 8 bytes of error coded file.)

VII. Secret Sharing

Shamir's Threshold Scheme: Implement Shamir's general threshold scheme, as described, for example, in the Handbook of Applied Cryptography.
CRT Threshold Scheme: Implement a general threshold scheme based on the Chinese Remainder Theorem. (I can give you a reference to this, also called the Asmuth-Bloom Scheme.) You will need the BigInteger class or some other code to do high-precision integer arithmetic.
Generalized Threshold Schemes: Research and implement on of the many generalized threshold schemes.

VIII. Discrete Logarithms

The Diffie-Hellman Key Exchange Scheme: Implement Diffie-Hellman.
Time-memory tradeoff to calculate discrete logarithms: Implement this time-memory tradeoff.
ElGamel Public Key Encryption and Signature Schemes: Implement ElGamel.
Mental Poker: Look this up and implement it.

IX. One-way Functions

Traditional one-way functions: Implement one of the traditional one-way functions described in the notes (using for example the AES).
Strong one-way functions: Implement one of the three strong one-way functions mentioned in the notes.
Unix password files: Implement a Unix-style encrypted password file. Use a salt.

Revision date: 2002-01-13. (Please use ISO 8601, the International Standard.)