SHA-1 hashing concept in Git - Step-by-Step Execution

Process Flow - SHA-1 hashing concept

Input Data

↓

Preprocessing

↓

Split into Blocks

↓

Initialize Hash Values

↓

Process Each Block

↓

Compression Function

↓

Update Hash

↓

Final SHA-1 Hash Output

SHA-1 takes input data, processes it in blocks through a compression function, and produces a fixed 40-character hash string.

Execution Sample

Git

echo -n "hello" | sha1sum
2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

This command computes the SHA-1 hash of the string "hello" and outputs the hash.

Process Table

Step	Action	Input/State	Output/State
1	Input Data	"hello"	"hello"
2	Preprocessing	"hello"	"hello" + padding + length info
3	Split into Blocks	Preprocessed data	One 512-bit block
4	Initialize Hash Values	N/A	5 initial 32-bit words (h0-h4)
5	Process Block	512-bit block + h0-h4	80 words prepared for rounds
6	Compression Function	80 words + h0-h4	Updated h0-h4 values
7	Update Hash	Updated h0-h4	Final 160-bit hash
8	Output Hash	160-bit hash	"2aae6c35c94fcfb415dbe95f408b9ce91ee846ed" (hex)

💡 All blocks processed; final 160-bit SHA-1 hash produced as hex string.

Status Tracker

Variable	Start	After Step 4	After Step 6	Final
Input Data	"hello"	"hello"	"hello" + padding	"hello" + padding
Blocks	N/A	N/A	One 512-bit block	One 512-bit block
h0-h4	N/A	Initial constants	Updated by compression	Final hash words
Hash Output	N/A	N/A	N/A	"2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

Key Moments - 3 Insights

Why does the input data get padded before processing?

Padding ensures the data length is a multiple of 512 bits, which is required for SHA-1 to process data in fixed-size blocks, as shown in step 2 and 3 of the execution table.

What are h0 to h4 in the SHA-1 process?

They are initial fixed 32-bit words used as starting hash values, updated during processing (steps 4 to 6), eventually forming the final hash output.

Why is the final output a 40-character string?

Because SHA-1 produces a 160-bit (20-byte) hash, which is represented as 40 hexadecimal characters (2 hex chars per byte), as shown in step 8.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of h0-h4 after step 4?

A Initial constants ready for processing

B Final hash values

C Input data padded

D Blocks split into 512-bit chunks

💡 Hint

Refer to step 4 in the execution table where hash values are initialized.

At which step does the input data get split into blocks?

A Step 5

B Step 2

C Step 3

D Step 7

💡 Hint

Check the 'Split into Blocks' action in the execution table.

If the input string changes, which part of the execution table will definitely change?

A Initialize Hash Values

B Compression Function output

C Padding step only

D Final output hash remains same

💡 Hint

Look at how the compression function output depends on input data blocks and hash values.

Concept Snapshot

SHA-1 hashing:
- Input data is padded to multiple of 512 bits
- Data split into 512-bit blocks
- Initial hash values (h0-h4) set
- Each block processed with compression function
- Final output is 160-bit hash (40 hex chars)
- Used in git to identify objects uniquely

Full Transcript

SHA-1 hashing takes any input data and processes it to produce a fixed-length 40-character hexadecimal string. The process starts by padding the input so its length is a multiple of 512 bits. Then the data is split into 512-bit blocks. Five initial hash values (h0 to h4) are set as constants. Each block is processed through a compression function that updates these hash values. After all blocks are processed, the final 160-bit hash is output as a 40-character hex string. This hash uniquely represents the input data and is used in git to track files and commits.