> For the complete documentation index, see [llms.txt](https://hub.bsvblockchain.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hub.bsvblockchain.org/higher-learning/bsv-academy/bitcoin-primitives-hash-functions/walkthrough-implementation-of-sha-256-in-golang-overview/sha-256-compression.md).

# SHA-256 Compression

{% embed url="<https://youtu.be/WANpKKYOF2o>" %}

The **compression step** of SHA-256 transforms each **512-bit message block** into an updated internal state. It consists of three main phases:

1. **Initialization of registers** (working variables)
2. **Computation of temporary words and register mutations**
3. **Integration of results** into the hash state

***

#### 1. Initialization of Registers

SHA-256 starts with **eight working variables (a–h)**.

* For the **first round**, these registers are initialized from **constants**: the fractional square roots of the first **eight prime numbers**.
* For **subsequent rounds**, they are set to the **results (chaining variables)** from the previous block.

Example in Go:

```
// First 8 primes: 2, 3, 5, 7, 11, 13, 17, 19
func InitializeRegisters() []uint32 {
    registerValues := []uint32{}
    for i := 0; i < 8; i++ {
        root := math.Pow(float64(First_eight_primes[i]), 0.5)
        value, _ := math.Modf(root * (1 << 32))
        registerValues = append(registerValues, uint32(value))
    }
    return registerValues
}
// Output: [6a09e667, bb67ae85, 3c6ef372, a54ff53a, 510e527f, 9b05688c, 1f83d9ab, 5be0cd19]
```

👉 **Key takeaway:** These values provide the **starting point** for SHA-256 compression.

***

#### 2. Temporary Words and Register Mutations

For each of the **64 words** in the message schedule, SHA-256 computes:

* tempWord1 = h + Σ1(e) + Choice(e,f,g) + K\[i] + W\[i]
* tempWord2 = Σ0(a) + Majority(a,b,c)

Then, the working variables are **rotated and updated**:

```
for i := 0; i < 64; i++ {
    tempWord1 := h + BigSigmaOne(e) + Choice(e,f,g) + constants[i] + messageSchedule[i]
    tempWord2 := BigSigmaZero(a) + Majority(a,b,c)

    h = g
    g = f
    f = e
    e = d + tempWord1
    d = c
    c = b
    b = a
    a = tempWord1 + tempWord2
}
```

&#x20;

The four **logical functions** that power SHA-256’s security are:

```
// Σ0(x) = ROTR2(x) XOR ROTR13(x) XOR ROTR22(x)
func BigSigmaZero(x uint32) uint32 {
    return bits.RotateLeft32(x, -2) ^ bits.RotateLeft32(x, -13) ^ bits.RotateLeft32(x, -22)
}

// Σ1(x) = ROTR6(x) XOR ROTR11(x) XOR ROTR25(x)
func BigSigmaOne(x uint32) uint32 {
    return bits.RotateLeft32(x, -6) ^ bits.RotateLeft32(x, -11) ^ bits.RotateLeft32(x, -25)
}

// Choice(x,y,z) = (x & y) ^ (^x & z)
func Choice(x,y,z uint32) uint32 {
    return (x & y) ^ (^x & z)
}

// Majority(x,y,z) = (x & y) ^ (x & z) ^ (y & z)
func Majority(x,y,z uint32) uint32 {
    return (x & y) ^ (x & z) ^ (y & z)
}
```

&#x20;

👉 These **bitwise operations** (rotate, shift, XOR, AND, OR) give SHA-256 its **preimage, second preimage, and collision resistance**.

***

#### 3. Final Integration

At the end of 64 rounds, the **working variables (a–h)** are added back to the **initial values** to produce the **chaining variables**:

```
hv0 := a + initialValues[0]
hv1 := b + initialValues[1]
hv2 := c + initialValues[2]
hv3 := d + initialValues[3]
hv4 := e + initialValues[4]
hv5 := f + initialValues[5]
hv6 := g + initialValues[6]
hv7 := h + initialValues[7]

fmt.Printf("Output: [%x, %x, %x, %x, %x, %x, %x, %x]\n", hv0,hv1,hv2,hv3,hv4,hv5,hv6,hv7)
```

&#x20;

For the input `"abc"`, the final digest is:

```
[ba7816bf, 8f01cfea, 414140de, 5dae2223, 
 b00361a3, 96177a9c, b410ff61, f20015ad]
```

This concatenated result is the **SHA-256 hash output**.

***

✅ **Summary:**

* Registers are **initialized** from prime-based constants (or chaining values).
* Each message schedule word passes through **64 rounds** of **bitwise mixing**.
* The updated registers are combined into the **final digest**.

👉 This iterative process makes SHA-256 both **efficient** and **secure**, powering Bitcoin’s **proof-of-work** and **transaction integrity**.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://hub.bsvblockchain.org/higher-learning/bsv-academy/bitcoin-primitives-hash-functions/walkthrough-implementation-of-sha-256-in-golang-overview/sha-256-compression.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
