crypt (Unix)

In Unix computing, crypt is the name of both a utility program and a C programming function. Though both are used for encrypting data, they are otherwise essentially unrelated. To distinguish between the two, writers often refer to the utility program as crypt(1), because it is documented in section 1 of the Unix manual pages, and refer to the C library function as crypt(3), because its documentation is in manual section 3.

Command filter crypt(1)

crypt(1) is a simple command to encrypt or decrypt data. Usually this is used as a filter and it has traditionally been implemented using an algorithm based on the Enigma machine. It is considered to be far too cryptographically weak to provide any security against brute force attacks by modern, commodity personal computers.

Some versions of Unix shipped with an even weaker version of the crypt(1) command in order to comply with contemporaneous laws and regulations^{[citation needed]} which limited the exportation of cryptographic software (for example by classifying them as munitions). Some of these were simply implementations of the Caesar cipher (effectively no more secure than ROT13 which is implemented as a Caesar cipher with a well known key).

crypt(1) under Linux

Linux distributions generally do not include a Unix compatible version of the crypt command. This is largely due to a combination of three major factors:

1. crypt is relatively obscure and rarely used for e-mail attachments nor as a file format
2. crypt is considered far too cryptographically weak to withstand brute force attacks by modern computing systems (Linux systems generally ship with GNU Privacy Guard which is considered to be reasonably secure by modern standards)
3. During the early years of Linux development and adoption there was some concern that even as weak as the algorithm used by crypt was, that it might still run afoul of ITAR's export controls; so mainstream distribution developers in the United States generally excluded it (and left their customers to fetch GnuPG/GPG or other strong cryptographic software from international sites, sometimes providing packages or scripts to automate that process).

The source code to several old versions of the crypt command is available in The Unix Heritage Society's Unix Archive.

Enhanced symmetric encryption utilities are available for Linux (and should also be portable to any other Unix-like system) including mcrypt and ccrypt.^[1] While these provide support for much more sophisticated and modern algorithms, they can be used to encrypt and decrypt files which are compatible with the traditional crypt(1) command by providing the correct command line options.

Breaking crypt(1) encryption

Programs for breaking crypt(1) encryption are widely available. Bob Baldwin's Crypt Breaker's Workbench,^[2] which was written in 1984-1985, is an interactive tool that provides successive plaintext guesses that must be corrected by the user. Peter Selinger's unixcrypt-breaker^[3] uses a simple statistical model to guess plausible plaintexts, and does not require user interaction.

Library Function crypt(3)

crypt(3) is the library function which is used to compute a password hash that can be used to store user account passwords while keeping them relatively secure (a passwd file). The output of the function is not simply the hash— it is a text string which also encodes the salt (usually the first two characters), and identifies the hash algorithm used (defaulting to the "traditional" one explained below). This output string is what is meant for putting in a password record which may be stored in a plain text file.

This same crypt(3) function is used both to generate a new hash for storage and also to hash a proffered password with a recorded salt for comparison.

If the salt begins with the string $digit$ then the Modular Crypt Format is used. The digit represents which algorithm is used in encryption.

The crypt() library function is also included in the Perl[1], PHP[2], Pike[3], Python[4], and Ruby[5] programming languages.

Traditional DES-based scheme

The traditional implementation uses a modified form of the DES algorithm. The user's password is truncated to eight characters, and those are coerced down to only 7-bits each; this forms the 56-bit DES key. That key is then used to encrypt an all-bits-zero block, and then the ciphertext is encrypted again with the same key, and so on for a total of 25 DES encryptions. A 12-bit salt is used to perturb the encryption algorithm, so standard DES implementations can't be used to implement crypt(). The salt and the final ciphertext are encoded into a printable string in a form of base64.

This is technically not encryption since the data (all bits zero) is not being kept secret; it's widely known to all in advance. However, one of the properties of DES is that it's very resistant to key recovery even in the face of known plaintext situations. It is theoretically possible that two different passwords could result in exactly the same hash. Thus the password is never "decrypted": it is merely used to compute a result, and the matching results are presumed to be proof that the passwords were "the same."

The advantages of this method have been that the password can be stored in plain text and copied among Unix systems without being exposed to the system administrators or other users. This portability has worked for over 30 years across many generations of computing architecture, and across many versions of Unix from many vendors.

Modifications of the traditional scheme

crypt(3) was originally chosen because DES was resistant to key recovery even in the face of "known plaintext" attacks, and because it was computationally expensive. On the earliest Unix machines it took over a full second to compute a password hash. This also made it reasonably resistant to dictionary attacks in that era. At that time password hashes were commonly stored in an account file (/etc/passwd) which was readable to anyone on the system. (This account file was also used to map user ID numbers into names, and user names into full names, etc.).

In the three decades since that time, computers have become vastly more powerful. Moore's Law has generally held true, so the computer speed and capacity available for a given financial investment has doubled over 20 times since Unix was first written. This has long since left the crypt(3) function vulnerable to dictionary attacks, and Unix and Unix-like systems such as Linux have used "shadow" files for a long time, migrating just the password hash values out of the account file (/etc/passwd) and into a file (conventionally named /etc/shadow) which can only be read by privileged processes.

To increase the computational cost of password breaking, some Unix sites privately started increasing the number of encryption rounds on an ad hoc basis.^{[citation needed]} This had the side effect of making their crypt() incompatible with the standard crypt(): the hashes had the same textual form, but were now calculated using a different algorithm. Some sites also took advantage of this incompatibility effect, by modifying the initial block from the standard all-bits-zero.^{[citation needed]} This did not increase the cost of hashing, but meant that precomputed hash dictionaries based on the standard crypt() could not be applied.

BSDi extended DES-based scheme

To gain greater cryptographic security and resistance to brute-force attacks, modern versions of Unix now have a variety of new password hash schemes implemented using the crypt() interface. BSDi modified the original DES-based scheme, extending the salt to 24 bits and making the number of rounds variable (up to 2²⁴-1). The chosen number of rounds is encoded in the stored password hash, avoiding the incompatibility that occurred when sites modified the number of rounds used by the original scheme. These hashes are identified by starting with _.

The BSDi algorithm also supports longer passwords, using DES to fold the initial long password down to the eight 7-bit bytes supported by the original algorithm.

MD5-based scheme

Poul-Henning Kamp designed a baroque and (at the time) computationally expensive algorithm based on the MD5 message digest algorithm. MD5 itself would provide good cryptographic strength for the password hash, but it is designed to be quite quick to calculate relative to the strength it provides. The crypt() scheme is designed to be expensive to calculate, to slow down dictionary attacks. The printable form of MD5 password hashes starts with $1$.

This scheme allows users to have any length password, and they can use any characters supported by their platform (not just 7-bit ASCII). (In practice many implementations limit the password length, but they generally support passwords far longer than any person would be willing to type.) The salt is also an arbitrary string, limited only by character set considerations.

First the passphrase and salt are hashed together, yielding an MD5 message digest. Then a new digest is constructed, hashing together the passphrase, the salt, and the first digest, all in a rather complex form. Then this digest is passed through a thousand iterations of a function which rehashes it together with the passphrase and salt in a manner that varies between rounds. The output of the last of these rounds is the resulting passphrase hash.

The fixed iteration count has caused this scheme to lose the computational expense that it once enjoyed. Variable numbers of rounds are now favoured.

Blowfish-based scheme

Niels Provos and David Mazières designed a crypt() scheme called bcrypt based on Blowfish, and presented it at USENIX in 1999.^[4] The printable form of these hashes starts with $2$ or $2a$, depending on which variant of the algorithm is used.

Blowfish is notable among block ciphers for its expensive key setup phase. It starts off with subkeys in a standard state, then uses this state to perform a block encryption using part of the key, and uses the result of that encryption (really, a hashing) to replace some of the subkeys. Then it uses this modified state to encrypt another part of the key, and uses the result to replace more of the subkeys. It proceeds in this fashion, using a progressively modified state to hash the key and replace bits of state, until all subkeys have been set.

Provos and Mazières took advantage of this, and actually took it further. They developed a new key setup algorithm for Blowfish, dubbing the resulting cipher "Eksblowfish" ("expensive key schedule Blowfish"). The key setup begins with a modified form of the standard Blowfish key setup, in which both the salt and password are used to set all subkeys. Then there is a configurable number of rounds in which the standard Blowfish keying algorithm is applied, using alternately the salt and the password as the key, each round starting with the subkey state from the previous round. This is not cryptographically significantly stronger than the standard Blowfish key schedule; it simply makes the algorithm arbitrarily slow to deter brute-force attacks.

The number of rounds of keying is a power of two, which is an input to the algorithm. The number is encoded in the textual hash.

NT Hash Scheme

FreeBSD implemented support for the NT LAN Manager hash algorithm to provide easier compatibility with NT accounts.^[5] The NT-Hash algorithm is known to be weak, as it uses the deprecated md4 hash algorithm without any salting.^[6] FreeBSD used the $3$ prefix for this. Its use is not recommended, as it is easily broken.^[7]

SHA2-based scheme

The commonly used MD5 based scheme has become easier to attack as computer power has increased. Although the Blowfish-based system has the option of adding rounds and thus remain a challenging password algorithm, it does not use a NIST-approved algorithm. In light of these facts, Ulrich Drepper of Red Hat led an effort to create a scheme based on the SHA-2 (SHA-256 and SHA-512) hash functions.^[8] The printable form of these hashes starts with $5$ or $6$ depending on which SHA variant is used. Its design is similar to the MD5-based crypt, with a few notable differences:^[8]

• It avoids adding constant data in a few steps.
• The MD5 algorithm would repeatedly add the first letter of the password;^{[citation needed]} this step was changed significantly.
• Inspired by Sun's crypt() implementation, functionality to specify the number of rounds the main loop in the algorithm performs was added^[9][10]

The specification and sample code have been released into the public domain.^[11]

crypt(3) under Linux

The GNU C Library used by almost all Linux distributions provides an implementation of the crypt function which supports the DES, MD5, and SHA-2 (since version 2.7) based hashing algorithms mentioned above.

References

1. ^ Peter Selinger: ccrypt. Retrieved July 27, 2008.
2. ^ Bob Baldwin: Crypt Breaker's Workbench, written 1984-1985. Retrieved July 27, 2008.
3. ^ Peter Selinger: unixcrypt-breaker. Retrieved July 27, 2008.
4. ^ Provos, Niels; Mazières, David (1999). "A Future-Adaptable Password Scheme". Proceedings of 1999 USENIX Annual Technical Conference: 81–92. http://www.usenix.org/events/usenix99/provos/provos_html/node1.html. 
5. ^ http://www.mail-archive.com/[e-mail]/msg52586.html
6. ^ http://davenport.sourceforge.net/ntlm.html#theNtlmResponse
7. ^ http://www.freebsd.org/cgi/man.cgi?query=crypt&apropos=0&sektion=3&manpath=FreeBSD+8.2-RELEASE&format=html
8. ^ ^{a b} Drepper, Ulrich. "Unix crypt with SHA-256/512". http://people.redhat.com/drepper/sha-crypt.html. 
9. ^ Sun Microsystems. "crypt_sunmd5(5) man page". http://docs.sun.com/app/docs/doc/816-5175/6mbba7evg. Retrieved 2008-03-05. 
10. ^ Muffett, Alec (2005-12-05). "OpenSolaris, Pluggable Crypt, and the SunMD5 Password Hash Algorithm". http://www.crypticide.com/dropsafe/article/1389. Retrieved 2008-03-05. 
11. ^ Drepper, Ulrich. "Unix crypt using SHA-256 and SHA-512". http://www.akkadia.org/drepper/SHA-crypt.txt. 

External links

• Source code for crypt(1) from Seventh Edition Unix (trivialised one-rotor Enigma-style machine)
• Source code for crypt(3) from Seventh Edition Unix (implements proposed DES)
• Source code for crypt(1) from Sixth Edition Unix (implementation of Boris Hagelin's cryptographic machine)