What are the different steps in SHA-256?

The SHA-256 algorithm is a part of the SHA-2Secure Hashing Algorithm 2, a set of secure cryptographic hash functions used for the protection and encryption of online data.

We can divide the algorithm for SHA-256 into three steps, as outlined below.

Step one: Appending bits

The first step involves preprocessing the input message to make it compatible with the hash function. It can be divided into two main substeps:

Padding bits

The total length of our message must be a multiple of $512$. In this step, we append bits to the end of our message such that the final length of the message must be 64 bits less than a multiple of 512. The formula below depicts this step:

        $m+p=(n*512)-64$

where $m$ = length of the message, $p$ = length of the padding, and $n$ = a constant.

The first bit that we append is $1$ followed by all $0$ bits.

Length bits

Next, we take the modulus of the original message with 2³² to get $64$ bits of data. Appending this to the padded message makes our processed message an exact multiple of $512$.

The image below illustrates the final message after step one is completed.

Step two: Buffer initialization

Before we begin carrying out computations on the message, we need to initialize some buffer values. The default eight buffer values are shown below. These are hard-coded constants representing hash values.

Moreover, we have to initialize an array containing $64$ constants, denoted by $k$.

Step three: Compression function

Now that we have our message and buffers ready, we can begin computation. Recall that our processed message is $n*512$ bits long. This will be divided into $n$ chunks of $512$ bits. Each of these chunks is then put through $64$ rounds of operations and the output from each round serves as the next input.

The image below illustrates the complete cycle:

Moreover, each input consists of two constants—$K(i)$ and $W(i)$. $K(i)$ is pre-initialized and $W(i)$ is initialized by breaking each of the $512$ bit chunks into $16$ subblocks of $32$ bits each for the first 16 rounds. After that, $W(i)$ must be calculated at each subsequent round. The following formulas show the calculation:

1. $s^0=(W[i-15]$ right rotate $7)$ XOR $(W[i-15]$ right rotate $18)$ XOR $(W[i-15]$ right shift $3)$

2. $s^1=(W[i-2]$ right rotate $17)$ XOR $(W[i-2]$ right rotate $19)$ XOR $(W[i-2]$ right shift $10)$

3. $W(i) = W[i-16] + s⁰ + W[9-7] + s¹<br>$

Now that we know how a message chunk is processed, let us take a look at each round. Consider the diagram below:

Each round carries out the following set of computations:

• $Ch = (E$ AND $F)$XOR $(($NOT $E)$ AND $G)$

• $Ma = (A$ AND $B)$XOR $(A$AND $C)$ XOR $(B$ AND $C)$

• $∑A = (A>>>2)$XOR $(A >>> 13)$XOR $(A >>> 22)$

• $∑E = (E>>>6)$XOR $(E >>> 11)$XOR $(E >>> 25)$

• $Am=$(addition) mod (2³² )

The output from each round is fed as input to the next round until the last chunk is reached. The output from the last block will be the final hash digest of length $256$ bits.

Let's encapsulate steps of the SHA-256 algorithm using the hashlib.sha256() to generate a hash for any data entered into the following widget.