CS6238 Secure Computer Systems
Programming Assignment 2
Due Date: 11:59pm May 4th, 2005
In this programming project, you will build a simple secure distributed file system (SDFS)
where applications can access files from remote locations. The SDFS will allow clients to store
and access information that has confidentiality or integrity requirements. Since client nodes will
communicate with the SDFS over an open network, secure information access will require that
messages exchanged between nodes are encrypted. You can use either the Java Crypto
Extension packages or the OpenSSL toolkit to complete this project. Since the project
requires communication between different machines, you should be familiar with sockets
programming.
You can build your secure distributed file system above the host file systems, which already
implements the interfaces to store & retrieve file contents via open()/read()/write()/close().
Specifically, you can extend the host file system via wrappers in the following manner. At the
time a client creates a file, based on the contents of the file, he/she would decide what kind of
security guarantees are needed for the file data, which will be stored in the file. Three kinds of
security guarantees will be made available to applications: CFS files provide confidentiality,
IFS files will ensure integrity for data stored in them, and nFS files will not provide either of
these guarantees. Accesses to all files will need to be authorized based on ACLs (to simplify
the task, you are not required to manage the group permissions) and hence clients will have to
be authenticated. Authentication should be done using a public-key based protocol that was
discussed in class for creating secure node-to-node channels. Furthermore, CFS files must be
stored in encrypted form to guard against accidental disclosure of information, and secure
channels must be used to communicate data from such files over the network. Since CFS files
are stored in encrypted form, you need to worry about the management of keys that are used
for such encryption. You can generate a random symmetric key, encrypt the file using it, and
encrypt the key with the public keys of those users who have access to the file based on its
ACL. The encrypted keys can themselves be stored with the other meta-data that you maintain
about the file. If a user should be able to access the file, it will also be able to retrieve the key
that will be needed to decrypt the CFS file.
In addition to the file server, which will accept and process the incoming file access requests,
you will also create a certification authority (CA) that signs and provides storage for certificates
that belong to the server and the clients (minimally, the CA could be just a file that store
certificates that you generate). A client will establish a connection with the server by
authenticating itself, access files, and then terminate its session. Clearly, files persist at the
servers unless they are deleted by their owners. You can assume that the file server and CA
are at well known locations.
