# SHA3 384 bits Hash Calculator

## Calculate the SHA3 384 bits Hash from UTF-8 Text

Simply use the form below

*input*

**SHA-3** (**Secure Hash Algorithm 3**), a subset of the cryptographic primitive family **Keccak** (/ˈkɛtʃæk/, or /kɛtʃɑːk/), is a cryptographic hash function designed by Guido Bertoni, Joan Daemen, Michaël Peeters, and Gilles Van Assche, building upon RadioGatún. SHA-3 is a member of the Secure Hash Algorithm family. The SHA-3 standard was released by NIST on August 5, 2015. The reference implementation source code was dedicated to public domain via CC0 waiver.

**Design**

SHA-3 uses the sponge construction, in which data is "absorbed" into the sponge, then the result is "squeezed" out. In the absorbing phase, message blocks are XORed into a subset of the state, which is then transformed as a whole. In the "squeeze" phase, output blocks are read from the same subset of the state, alternated with state transformations. The size of the part of the state that is written and read is called the "rate" (often denoted *r*), and the size of the part that is untouched by input/output is called the "capacity" (often denoted *c*). The capacity determines the security of the scheme. The maximum security level is half the capacity.

In SHA-3, the state consists of a 5 × 5 array of 64-bit words, 1600 bits total. Keccak is also defined for smaller power-of-2 word sizes *w* down to 1 bit (25 bits total state). Small state sizes can be used to test cryptanalytic attacks, and intermediate state sizes (from *w* = 8, 200 bits, to *w* = 32, 800 bits) can be used in practical, lightweight applications.

The block transformation is a permutation that uses **xor**, **and** and **not** operations, and designed for easy implementation in both software and hardware. The authors claim 12.5 cycles per byte on an Intel Core 2 CPU. However, in hardware implementations, it is notably faster than all other finalists.

Keccak's authors have proposed additional, not-yet-standardized uses for the function, including an authenticated encryption system and a "tree" hashing scheme for faster hashing on certain architectures.

**Comparison of SHA functions**

In the table below, *internal state* means the "internal hash sum" after each compression of a data block.

Note that performance will vary not only between algorithms, but also with the specific implementation and hardware used. The OpenSSL tool has a built-in "speed" command that benchmarks the various algorithms on the user's system.

Algorithm and variant | Output size (bits) |
Internal state size (bits) |
Block size (bits) |
Max message size (bits) |
Rounds | Operations | Security bits (Info) |
Example performance (MiB/s) |
First Published | |
---|---|---|---|---|---|---|---|---|---|---|

MD5 (as reference) |
128 | 128 (4 × 32) |
512 | Unlimited | 64 | And, Xor, Rot, Add (mod 2^{32}), Or |
<64 (collisions found) |
335 | 1992 | |

SHA-0 |
160 | 160 (5 × 32) |
512 | 2^{64} − 1 |
80 | And, Xor, Rot, Add (mod 2^{32}), Or |
<80 (collisions found) |
- | 1993 | |

SHA-1 |
160 | 160 (5 × 32) |
512 | 2^{64} − 1 |
80 | <63 (collision found) |
192 | 1995 | ||

SHA-2 |
SHA-224SHA-256 |
224 256 |
256 (8 × 32) |
512 | 2^{64} − 1 |
64 | And, Xor, Rot, Add (mod 2^{32}), Or, Shr |
112 128 |
139 | 2001 |

SHA-384SHA-512SHA-512/224SHA-512/256 |
384 512 224 256 |
512 (8 × 64) |
1024 | 2^{128} − 1 |
80 | And, Xor, Rot, Add (mod 2^{64}), Or, Shr |
192 256 112 128 |
154 | 2001 | |

SHA-3 |
SHA3-224SHA3-256SHA3-384SHA3-512 |
224 256 384 512 |
1600 (5 × 5 × 64) |
1152 1088 832 576 |
Unlimited | 24 | And, Xor, Rot, Not | 112 128 192 256 |
- | 2015 |

SHAKE128SHAKE256 |
d (arbitrary)d (arbitrary) |
1344 1088 |
min(d/2, 128)min( d/2, 256) |
- | 2015 |