Free distributed file system software for linux

Coda is an advanced networked filesystem. The project has been developed at CMU since 1987 by the systems group of M. Satyanarayanan. in the SCS department.
Coda is a distributed filesystem with its origin in AFS2. It has many features that are very desirable for network filesystems. Currently, Coda has several features not found elsewhere.
1. disconnected operation for mobile computing
2. is freely available under a liberal license
3. high performance through client side persistent caching
4. server replication
5. security model for authentication, encryption and access control
6. continued operation during partial network failures in server network
7. network bandwith adaptation
8. good scalability
9. well defined semantics of sharing, even in the presence of network failures
Enhancements:
- Coda now works on 64-bit systems.
- The client and server were successfully built and used on a machine with em64t extensions with a 64-bit Linux kernel.
- The new RVM-1.14 and RPC2-2.5 releases also incorporate some essential 64-bit fixes.
- Another welcome change is that venus now tries to keep cached access rights available for users even across system reboots or client restarts, which should improve life for people who frequently shut down or dual boot their machines.

Distributed BEAGLE provides a distributed evolutionary computation system.
Distributed BEAGLE is a master-slave distribution extension of the evolutionary computation framework, Open BEAGLE. Its key features are robustness, fault tolerance, adaptability for heterogeneous networks, and transparency for the user.
Main features:
- Based on the generic framework Open BEAGLE
- Minimal changes required to modify an Open BEAGLE application for distribution
- Ten GA and GP examples converted from Open BEAGLE
- Communication based on TCP sockets using XML encoding
- Data persistency insured on the server by a SQL Database (SQLite)
- Load balancing of computational tasks for uses on heterogeneous LAN
- Open source (LGPL license)
- OS-calls wrapped into generic C++ classes
- Compiles on UNIX (Linux/OS X) with gcc 3.x and Windows with Visual Studio .NET
Enhancements:
- Bug fixe: variable deme size could crash the server (Thanks CG).
- Suggestion: Compression of connections can now be activated by clients if the option is set to "-1".

Distributed FTP is a distributed FTP daemon written in java. Instead of usual and well-known serversclient transfer it uses masterclient for control connections and slaveclient for (most) data transfers, the master must tell the slave to initiate/respond to a transfer.

Distributed Artificial Life project uses spare CPU cycles to create life.

Distributed Artificial Life is a distributed version of Tom S. Rays Tierra artificial life program. It uses spare CPU cycles to simulate a distributed soup of living cells.

Note that the machine language used is similar to but not compatible with Tierra. Tom Ray talks about his work (as far as I know, never completed) to create a "Digital Reserve". The DLIFE project is a development of this.

In other words, its an alternative to the tedious process of cracking RC5 keys or searching for aliens. Youve got a supercomputer on your desk, lets go and create some life ...

It consists of a highly optimized engine for running the artificial life cells in a virtual machine, written in C, and some Perl scripts which can upload and download cells from central ``cell-bank servers.

Fast Secure File System exports existing directories securely over the network, letting users store and retrieve encrypted data in a scalable and transparent way. FSFS is written in C and works on GNU/Linux systems on x86 and PPC architectures, with help from FUSE and OpenSSL.
File systems are easily the most evident, from the point of view of users, component of an operating system. Through file systems it is possible to organize data in a wide variety of ways, and access resources through a common interface.
Users can nowadays not only store and retrieve documents, but also find information on running processes and system settings (through ProcFS), access and manipulate e-mail (for example with GmailFS), or perform several other operations.
In several circumstances and scenarios it is desirable to protect stored files and directories from manipulation by unknown or malicious users: financial or health-related data, confidential documents, or any kind of personal or sensitive data may need to be stored securely, in such a way that it can not be examined or modified freely by third parties.
Most file systems do not take action in this sense, and external cryptographic utilities are sometimes employed to secure data before storage. While this can be a perfectly secure solution, it is not transparent to users.
Distributed file systems propose efficient ways of accessing data remotely as if it resided on the local machine; when it comes to dealing with securely stored data as in the examples above, care must be taken to preserve confidentiality and integrity also during network transfer.
Not all distributed file systems accomplish this task, weakening the overall security of the system, or do so inefficiently, making it inconvenient for users.
FSFS is a secure, distributed file system in users space, written in C with much help from FUSE and OpenSSL. It lets users store and retrieve data securely and transparently, knowing that it is protected both on permanent storage devices and while in transit over the network.
It is also concerned with scalability, therefore separates data cryptography from the server, leaving it to the clients; this approach is similar to the one used in CFS, and opposite to those taken on by other secure file system solutions (like NFS on top of IPsec).
FSFS is written as a pair of user space daemons that act as client and server. Because of this, it needs no kernel support (unlike NFS over IPsec), save the FUSE loadable kernel module on clients, included in Linux since 2.6.14; servers dont use FUSE and depend only on user space OpenSSL libraries.
Servers export an existing file system (of virtually any kind) to clients over the network through two separate channels: a TLS connection set up with OpenSSL, and a clear channel. Requests from the clients to the servers are sent via the TLS socket, thus they are encrypted and authenticated, according to TLS v1 specifications, by the channel itself and decrypted on receipt, as they are usually very short and the relevant cryptography does not constitute a great overhead; simple server replies undergo the same process.
Cryptography in this case happens at both ends of the transmission.
In a distributed file system, large amounts of data may be transferred between clients and servers, thus encrypting and decrypting everything may become too cumbersome for both parties, and as more clients are added to the system the server may severely lose performance; moreover, file data should be stored encrypted anyway, so the cryptography could be moved to the clients, in such a way that each encrypts data before a write operation sends it over the network to the server, and decrypts it after a read retrieves it.
This way servers only deal with TLS details and can concentrate on serving client requests by doing the relevant I/O on the underlying, "physical" file system. As the data is already encrypted, it does not need to go through the TLS channel and the corresponding overhead, but can be sent via the clear channel, provided the messages are authenticated.
Enhancements:
- This release fixes two bugs. One bug related to socket creation and would cause problems on some systems (namely OpenSUSE 10.2). The other bug related to server configuration creation when using the Python configuration utilities. Users dont need to upgrade to this release if theyre not experiencing problems or are not using the Python configuration utilities.

Distributed Checksum Clearinghouse, in short DCC, is a system of clients and servers that collect and count checksums related to mail messages. The counts can be used by SMTP servers and mail user agents to detect and reject bulk mail.
DCC servers can exchange common checksums. The checksums include values that are "fuzzy", or constant across common variations in bulk messages.
Enhancements:
- This release improves the dccifd per-user whitelist default.
- It fixes the server database size estimate.
- Old installations really should upgrade to get the MIME decoding fix.

Distributed RSA Key Generation is a software to generate shared RSA keys. Currently, only keys for two parties using Gilboas protocol are supported. But the protocol stack is extensible, so in the future there may be other protocols supported.

Work has begun on Straubs protocol but is not finished yet, multi-party protocols like Boneh-Franklins may also be added in the far future.

Growler is a C++-based distributed object and event architecture. The software is written in C++, and supports serialization of C++ objects as part of its Remote Method Invocation, Event Channels, and in its Interface Definition Language.

Its primary application has been in support of interactive, distributed and collaborative visualization, computational steering, and concurrent visualization.