My files

[mymusic23]

https://github.com/ellemouton/cryptopals/blob/master/set4%2Fsha1%2Fsha1block.go#L1-L78

[AndersonCarrilho]

package main

import (
"fmt"
"math/bits"
)

// Constantes do SHA-1
const (
chunk = 64 // tamanho do bloco em bytes
_K0 = 0x5A827999
_K1 = 0x6ED9EBA1
_K2 = 0x8F1BBCDC
_K3 = 0xCA62C1D6
)

type Digest struct {
h [5]uint32
len uint64
buf []byte
}

// Inicializa o digest com valores padrão do SHA-1
func NewDigest() *Digest {
return &Digest{
h: [5]uint32{
0x67452301,
0xEFCDAB89,
0x98BADCFE,
0x10325476,
0xC3D2E1F0,
},
buf: make([]byte, 0, chunk),
}
}

// Atualiza o hash com novos dados
func (d *Digest) Write(p []byte) {
d.len += uint64(len(p))
d.buf = append(d.buf, p...)

// Processa blocos completos
for len(d.buf) >= chunk {
    block := d.buf[:chunk]
    blockGeneric(d, block)
    d.buf = d.buf[chunk:]
}

}

// Finaliza o hash e retorna o digest de 20 bytes
func (d *Digest) Sum() []byte {
// Padding
padding := []byte{0x80}
padding = append(padding, make([]byte, (56-len(d.buf)-1)%chunk+chunk-8)...)

// Adiciona o comprimento
lenBits := d.len * 8
lenBytes := make([]byte, 8)
for i := 0; i < 8; i++ {
    lenBytes[7-i] = byte(lenBits >> (i * 8))
}
d.Write(padding)
d.Write(lenBytes)

// Agora, o buffer deve estar vazio
var digest [20]byte
h := d.h
for i := 0; i < 5; i++ {
    digest[i*4] = byte(h[i] >> 24)
    digest[i*4+1] = byte(h[i] >> 16)
    digest[i*4+2] = byte(h[i] >> 8)
    digest[i*4+3] = byte(h[i])
}
return digest[:]

}

// blockGeneric is a portable, pure Go version of the SHA-1 block step.
// It's used by sha1block_generic.go and tests.
func blockGeneric(dig *Digest, p []byte) {
var w [16]uint32

h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4]
for len(p) >= chunk {
    // Can interlace the computation of w with the
    // rounds below if needed for speed.
    for i := 0; i < 16; i++ {
        j := i * 4
        w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
    }

    a, b, c, d, e := h0, h1, h2, h3, h4

    // Each of the four 20-iteration rounds
    // differs only in the computation of f and
    // the choice of K (_K0, _K1, etc).
    i := 0
    for ; i < 16; i++ {
        f := b&c | (^b)&d
        t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K0
        a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
    }
    for ; i < 20; i++ {
        tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
        w[i&0xf] = tmp<<1 | tmp>>(32-1)

        f := b&c | (^b)&d
        t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K0
        a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
    }
    for ; i < 40; i++ {
        tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
        w[i&0xf] = tmp<<1 | tmp>>(32-1)
        f := b ^ c ^ d
        t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K1
        a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
    }
    for ; i < 60; i++ {
        tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
        w[i&0xf] = tmp<<1 | tmp>>(32-1)
        f := ((b | c) & d) | (b & c)
        t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K2
        a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
    }
    for ; i < 80; i++ {
        tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
        w[i&0xf] = tmp<<1 | tmp>>(32-1)
        f := b ^ c ^ d
        t := bits.RotateLeft32(a, 5) + f + e + w[i&0xf] + _K3
        a, b, c, d, e = t, a, bits.RotateLeft32(b, 30), c, d
    }

    h0 += a
    h1 += b
    h2 += c
    h3 += d
    h4 += e

    p = p[chunk:]
}

dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4

}

func main() {
message := "Olá, SHA-1!"
d := NewDigest()
d.Write([]byte(message))
hash := d.Sum()

fmt.Printf("Mensagem: %s\nSHA-1: ", message)
for _, b := range hash {
    fmt.Printf("%02x", b)
}
fmt.Println()

}