SHA1(3) | Library Functions Manual | SHA1(3)

# NAME

`SHA1`, `SHA1_Init`, `SHA1_Update`, `SHA1_Final`, `SHA224`, `SHA224_Init`, `SHA224_Update`, `SHA224_Final`, `SHA256`, `SHA256_Init`, `SHA256_Update`, `SHA256_Final`, `SHA384`, `SHA384_Init`, `SHA384_Update`, `SHA384_Final`, `SHA512`, `SHA512_Init`, `SHA512_Update`, `SHA512_Final` — Secure Hash Algorithm

# SYNOPSIS

library “libcrypto”
`#include <openssl/sha.h>`

unsigned char *
`SHA1`(const unsigned char *d, size_t n, unsigned char *md);

int
`SHA1_Init`(SHA_CTX *c);

int
`SHA1_Update`(SHA_CTX *c, const void *data, size_t len);

int
`SHA1_Final`(unsigned char *md, SHA_CTX *c);

unsigned char *
`SHA224`(const unsigned char *d, size_t n, unsigned char *md);

int
`SHA224_Init`(SHA256_CTX *c);

int
`SHA224_Update`(SHA256_CTX *c, const void *data, size_t len);

int
`SHA224_Final`(unsigned char *md, SHA256_CTX *c);

unsigned char *
`SHA256`(const unsigned char *d, size_t n, unsigned char *md);

int
`SHA256_Init`(SHA256_CTX *c);

int
`SHA256_Update`(SHA256_CTX *c, const void *data, size_t len);

int
`SHA256_Final`(unsigned char *md, SHA256_CTX *c);

unsigned char *
`SHA384`(const unsigned char *d, size_t n, unsigned char *md);

int
`SHA384_Init`(SHA512_CTX *c);

int
`SHA384_Update`(SHA512_CTX *c, const void *data, size_t len);

int
`SHA384_Final`(unsigned char *md, SHA512_CTX *c);

unsigned char *
`SHA512`(const unsigned char *d, size_t n, unsigned char *md);

int
`SHA512_Init`(SHA512_CTX *c);

int
`SHA512_Update`(SHA512_CTX *c, const void *data, size_t len);

int
`SHA512_Final`(unsigned char *md, SHA512_CTX *c);

# DESCRIPTION

SHA-1 (Secure Hash Algorithm) is a cryptographic hash function with a 160-bit output.

`SHA1`() computes the SHA-1 message digest of the n bytes at d and places it in md, which must have space for `SHA_DIGEST_LENGTH` == 20 bytes of output.

The following functions may be used if the message is not completely stored in memory:

`SHA1_Init`() initializes a SHA_CTX structure.

`SHA1_Update`() can be called repeatedly with chunks of the message to be hashed (len bytes at data).

`SHA1_Final`() places the message digest in md, which must have space for `SHA_DIGEST_LENGTH` == 20 bytes of output, and erases the SHA_CTX.

The SHA224, SHA256, SHA384, and SHA512 families of functions operate in the same way as the SHA1 functions. Note that SHA224 and SHA256 use a SHA256_CTX object instead of SHA_CTX, and SHA384 and SHA512 use SHA512_CTX. The buffer md must have space for the output from the SHA variant being used: `SHA224_DIGEST_LENGTH`, `SHA256_DIGEST_LENGTH`, `SHA384_DIGEST_LENGTH`, or `SHA512_DIGEST_LENGTH` bytes.

Applications should use the higher level functions EVP_DigestInit(3) etc. instead of calling the hash functions directly.

# RETURN VALUES

`SHA1`(), `SHA224`(), `SHA256`(), `SHA384`(), and `SHA512`() return a pointer to the hash value. The other functions return 1 for success or 0 otherwise.

# SEE ALSO

EVP_DigestInit(3), HMAC(3), RIPEMD160(3)

# STANDARDS

Secure Hash Standard (SHS), NIST FIPS Publication, 180-4, https://doi.org/10.6028/NIST.FIPS.180-4, 2015.

# HISTORY

`SHA1`(), `SHA1_Init`(), `SHA1_Update`(), and `SHA1_Final`() first appeared in SSLeay 0.5.1 and have been available since OpenBSD 2.4.

The other functions first appeared in OpenSSL 0.9.8 and have been available since OpenBSD 4.5.

# CAVEATS

Other implementations allow md in `SHA1`(), `SHA224`(), `SHA256`(), `SHA384`(), and `SHA512`() to be `NULL` and return a static array, which is not thread safe.

June 8, 2025 | Debian