# crypt

## NAME



           crypt, crypt_r - password hashing
    


## LIBRARY



           Password hashing library (_libcrypt_ , _-lcrypt_)
    


## SYNOPSIS



           **#include <unistd.h>**
    
           **char *crypt(const char ***_key_**, const char ***_salt_**);**
    
           **#include <crypt.h>**
    
           **char *crypt_r(const char ***_key_**, const char ***_salt_**,**
                         **struct crypt_data *restrict** _data_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **crypt**():
               Since glibc 2.28:
                   _DEFAULT_SOURCE
               glibc 2.27 and earlier:
                   _XOPEN_SOURCE
    
           **crypt_r**():
               _GNU_SOURCE
    


## DESCRIPTION



           **crypt**() is the password hashing function.  It is based on the Data
           Encryption Standard algorithm with variations intended (among
           other things) to discourage use of hardware implementations of a
           key search.
    
           _key_ is a user's typed password.
    
           _salt_ is a two-character string chosen from the set [**a-zA-Z0-9./**].
           This string is used to perturb the algorithm in one of 4096
           different ways.
    
           By taking the lowest 7 bits of each of the first eight characters
           of the _key_ , a 56-bit key is obtained.  This 56-bit key is used to
           encrypt repeatedly a constant string (usually a string consisting
           of all zeros).  The returned value points to the hashed password,
           a series of 13 printable ASCII characters (the first two
           characters represent the salt itself).  The return value points to
           static data whose content is overwritten by each call.
    
           Warning: the key space consists of 2**56 equal 7.2e16 possible
           values.  Exhaustive searches of this key space are possible using
           massively parallel computers.  Software, such as **crack**(1), is
           available which will search the portion of this key space that is
           generally used by humans for passwords.  Hence, password selection
           should, at minimum, avoid common words and names.  The use of a
           passwd(1) program that checks for crackable passwords during the
           selection process is recommended.
    
           The DES algorithm itself has a few quirks which make the use of
           the **crypt**() interface a very poor choice for anything other than
           password authentication.  If you are planning on using the **crypt**()
           interface for a cryptography project, don't do it: get a good book
           on encryption and one of the widely available DES libraries.
    
           **crypt_r**() is a reentrant version of **crypt**().  The structure
           pointed to by _data_ is used to store result data and bookkeeping
           information.  Other than allocating it, the only thing that the
           caller should do with this structure is to set _data- >initialized_
           to zero before the first call to **crypt_r**().
    


## RETURN VALUE



           On success, a pointer to the hashed password is returned.  On
           error, NULL is returned.
    


## ERRORS



           **EINVAL** _salt_ has the wrong format.
    
           **ENOSYS** The **crypt**() function was not implemented, probably because
                  of U.S.A. export restrictions.
    
           **EPERM** _/proc/sys/crypto/fips_enabled_ has a nonzero value, and an
                  attempt was made to use a weak hashing type, such as DES.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌─────────────────────────┬───────────────┬──────────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├─────────────────────────┼───────────────┼──────────────────────┤
           │ **crypt**()                 │ Thread safety │ MT-Unsafe race:crypt │
           ├─────────────────────────┼───────────────┼──────────────────────┤
           │ **crypt_r**()               │ Thread safety │ MT-Safe              │
           └─────────────────────────┴───────────────┴──────────────────────┘
    


## STANDARDS



           **crypt**()
                  POSIX.1-2008.
    
           **crypt_r**()
                  GNU.
    


## NOTES



       **Features in glibc**
           The glibc version of this function supports additional hashing
           algorithms.
    
           If _salt_ is a character string starting with the characters "$_id_ $"
           followed by a string optionally terminated by "$", then the result
           has the form:
    
                  $_id_ $_salt_ $_hashed_
    
           _id_ identifies the hashing method used instead of DES and this then
           determines how the rest of the password string is interpreted.
           The following values of _id_ are supported:
                  **ID   Method**
                  ────────────────────────────────────────────────────────────
                  1    MD5
                  2a   Blowfish (not in mainline glibc; added in some Linux
                       distributions)
                  5    SHA-256 (since glibc 2.7)
                  6    SHA-512 (since glibc 2.7)
    
           Thus, $5$_salt_ $_hashed_ and $6$_salt_ $_hashed_ contain the password
           hashed with, respectively, functions based on SHA-256 and SHA-512.
    
           "_salt_ " stands for the up to 16 characters following "$_id_ $" in the
           salt.  The "_hashed_ " part of the password string is the actual
           computed password.  The size of this string is fixed:
                  **MD5** 22 characters
                  **SHA-256** 43 characters
                  **SHA-512** 86 characters
    
           The characters in "_salt_ " and "_hashed_ " are drawn from the set
           [**a-zA-Z0-9./**].  In the MD5 and SHA implementations the entire _key_
           is significant (instead of only the first 8 bytes in DES).
    
           Since glibc 2.7, the SHA-256 and SHA-512 implementations support a
           user-supplied number of hashing rounds, defaulting to 5000.  If
           the "$_id_ $"_characters_ in _the_ salt _are_ followed by "rounds=_xxx_ $", where
           _xxx_ is an integer, then the result has the form
    
                  $_id_ $_rounds=yyy_ $_salt_ $_hashed_
    
           where _yyy_ is the number of hashing rounds actually used.  The
           number of rounds actually used is 1000 if _xxx_ is less than 1000,
           999999999 if _xxx_ is greater than 999999999, and is equal to _xxx_
           otherwise.
    


* * *