---
name: "sha2"
section: "3"
platform: "linux"
package: "libmd"
version: "1.3.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/sha2"
---

# sha2(3)

calculate the NIST Secure Hash Standard (version 2)

## NAME

**SHA224Init**, **SHA224Update**, **SHA224Pad**, **SHA224Final**, **SHA224Transform**, **SHA224End**, **SHA224File**, **SHA224FileChunk**, **SHA224Data**, **SHA256Init**, **SHA256Update**, **SHA256Pad**, **SHA256Final**, **SHA256Transform**, **SHA256End**, **SHA256File**, **SHA256FileChunk**, **SHA256Data**, **SHA384Init**, **SHA384Update**, **SHA384Pad**, **SHA384Final**, **SHA384Transform**, **SHA384End**, **SHA384File**, **SHA384FileChunk**, **SHA384Data**, **SHA512Init**, **SHA512Update**, **SHA512Pad**, **SHA512Final**, **SHA512Transform**, **SHA512End**, **SHA512File**, **SHA512FileChunk**, **SHA512Data**, **SHA512\_224Init**, **SHA512\_224Update**, **SHA512\_224Pad**, **SHA512\_224Final**, **SHA512\_224Transform**, **SHA512\_224End**, **SHA512\_224File**, **SHA512\_224FileChunk**, **SHA512\_224Data**, **SHA512\_256Init**, **SHA512\_256Update**, **SHA512\_256Pad**, **SHA512\_256Final**, **SHA512\_256Transform**, **SHA512\_256End**, **SHA512\_256File**, **SHA512\_256FileChunk**, **SHA512\_256Data** – calculate the NIST Secure Hash Standard (version 2)

## LIBRARY

library “libmd”

## SYNOPSIS

**#include \<sys/types.h\>**

**#include \<sha2.h\>**

*void*\

**SHA224Init**(*SHA2\_CTX \*context*);

*void*\

**SHA224Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA224Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA224Final**(*uint8\_t digest\[SHA224\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA224Transform**(*uint32\_t state\[8\]*, *const uint8\_t buffer\[SHA224\_BLOCK\_LENGTH\]*);

*char \**\

**SHA224End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA224File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA224FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA224Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

*void*\

**SHA256Init**(*SHA2\_CTX \*context*);

*void*\

**SHA256Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA256Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA256Final**(*uint8\_t digest\[SHA256\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA256Transform**(*uint32\_t state\[8\]*, *const uint8\_t buffer\[SHA256\_BLOCK\_LENGTH\]*);

*char \**\

**SHA256End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA256File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA256FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA256Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

*void*\

**SHA384Init**(*SHA2\_CTX \*context*);

*void*\

**SHA384Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA384Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA384Final**(*uint8\_t digest\[SHA384\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA384Transform**(*uint64\_t state\[8\]*, *const uint8\_t buffer\[SHA384\_BLOCK\_LENGTH\]*);

*char \**\

**SHA384End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA384File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA384FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA384Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

*void*\

**SHA512Init**(*SHA2\_CTX \*context*);

*void*\

**SHA512Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA512Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA512Final**(*uint8\_t digest\[SHA512\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA512Transform**(*uint64\_t state\[8\]*, *const uint8\_t buffer\[SHA512\_BLOCK\_LENGTH\]*);

*char \**\

**SHA512End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA512File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA512FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA512Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

*void*\

**SHA512\_224Init**(*SHA2\_CTX \*context*);

*void*\

**SHA512\_224Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA512\_224Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA512\_224Final**(*uint8\_t digest\[SHA512\_224\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA512\_224Transform**(*uint64\_t state\[8\]*, *const uint8\_t buffer\[SHA512\_224\_BLOCK\_LENGTH\]*);

*char \**\

**SHA512\_224End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA512\_224File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA512\_224FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA512\_224Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

*void*\

**SHA512\_256Init**(*SHA2\_CTX \*context*);

*void*\

**SHA512\_256Update**(*SHA2\_CTX \*context*, *const uint8\_t \*data*, *size\_t len*);

*void*\

**SHA512\_256Pad**(*SHA2\_CTX \*context*);

*void*\

**SHA512\_256Final**(*uint8\_t digest\[SHA512\_256\_DIGEST\_LENGTH\]*, *SHA2\_CTX \*context*);

*void*\

**SHA512\_256Transform**(*uint64\_t state\[8\]*, *const uint8\_t buffer\[SHA512\_256\_BLOCK\_LENGTH\]*);

*char \**\

**SHA512\_256End**(*SHA2\_CTX \*context*, *char \*buf*);

*char \**\

**SHA512\_256File**(*const char \*filename*, *char \*buf*);

*char \**\

**SHA512\_256FileChunk**(*const char \*filename*, *char \*buf*, *off\_t offset*, *off\_t length*);

*char \**\

**SHA512\_256Data**(*const uint8\_t \*data*, *size\_t len*, *char \*buf*);

## DESCRIPTION

The SHA2 functions implement the NIST Secure Hash Standard, FIPS PUB 180-2. The SHA2 functions are used to generate a condensed representation of a message called a message digest, suitable for use as a digital signature. There are four families of functions, with names corresponding to the number of bits in the resulting message digest. The SHA-224 and SHA-256 functions are limited to processing a message of less than 2^64 bits as input. The SHA-384 and SHA-512 functions can process a message of at most 2^128 - 1 bits as input.

The SHA2 functions are considered to be more secure than the SHA1 functions, with which they share a similar interface. The 224, 256, 384, and 512-bit versions of SHA2 share the same interface. SHA512/224 and SHA512/256, truncated versions of SHA512, are also supported. For brevity, only the 256-bit variants are described below.

The **SHA256Init**() function initializes a SHA2\_CTX *context* for use with **SHA256Update**() and **SHA256Final**(). The **SHA256Update**() function adds *data* of length *len* to the SHA2\_CTX specified by *context*. **SHA256Final**() is called when all data has been added via **SHA256Update**() and stores a message digest in the *digest* parameter.

The **SHA256Pad**() function can be used to apply padding to the message digest as in **SHA256Final**(), but the current context can still be used with **SHA256Update**().

The **SHA256Transform**() function is used by **SHA256Update**() to hash 512-bit blocks and forms the core of the algorithm. Most programs should use the interface provided by **SHA256Init**(), **SHA256Update**(), and **SHA256Final**() instead of calling **SHA256Transform**() directly.

The **SHA256End**() function is a front end for **SHA256Final**() which converts the digest into an ASCII representation of the digest in hexadecimal.

The **SHA256File**() function calculates the digest for a file and returns the result via **SHA256End**(). If **SHA256File**() is unable to open the file, a NULL pointer is returned.

**SHA256FileChunk**() behaves like **SHA256File**() but calculates the digest only for that portion of the file starting at *offset* and continuing for *length* bytes or until end of file is reached, whichever comes first. A zero *length* can be specified to read until end of file. A negative *length* or *offset* will be ignored.

The **SHA256Data**() function calculates the digest of an arbitrary string and returns the result via **SHA256End**().

For each of the **SHA256End**(), **SHA256File**(), **SHA256FileChunk**(), and **SHA256Data**() functions the *buf* parameter should either be a string large enough to hold the resulting digest (e.g. SHA224\_DIGEST\_STRING\_LENGTH, SHA256\_DIGEST\_STRING\_LENGTH, SHA384\_DIGEST\_STRING\_LENGTH, SHA512\_DIGEST\_STRING\_LENGTH, SHA512\_224\_DIGEST\_STRING\_LENGTH, or SHA512\_256\_DIGEST\_STRING\_LENGTH, depending on the function being used) or a NULL pointer. In the latter case, space will be dynamically allocated via [malloc(3)](/malloc/3.md) and should be freed using [free(3)](/free/3.md) when it is no longer needed.

## EXAMPLES

The following code fragment will calculate the SHA-256 digest for the string "abc", which is “0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad”.

```
SHA2_CTX ctx;
uint8_t results[SHA256_DIGEST_LENGTH];
char *buf;
int n;
buf = "abc";
n = strlen(buf);
SHA256Init(&ctx);
SHA256Update(&ctx, (uint8_t *)buf, n);
SHA256Final(results, &ctx);
/* Print the digest as one long hex value */
printf("0x");
for (n = 0; n  SHA256_DIGEST_LENGTH; n++)
	printf("%02x", results[n]);
putchar('\n');
```

Alternately, the helper functions could be used in the following way:

```
uint8_t output[SHA256_DIGEST_STRING_LENGTH];
char *buf = "abc";
printf("0x%s\n", SHA256Data(buf, strlen(buf), output));
```

## SEE ALSO

[cksum(1)](/cksum/1.md), [md4(3)](/md4/3.md), [md5(3)](/md5/3.md), [rmd160(3)](/rmd160/3.md), [sha1(3)](/sha1/3.md) *Secure Hash Standard*, FIPS PUB 180-2.

## HISTORY

The SHA2 functions appeared in OpenBSD 3.4.

## AUTHORS

This implementation of the SHA functions was written by Aaron D. Gifford.

The **SHA256End**(), **SHA256File**(), **SHA256FileChunk**(), and **SHA256Data**() helper functions are derived from code written by Poul-Henning Kamp.