sha256.go

package main

import (
	"crypto/sha256"
	"encoding/binary"
	"fmt"
)

// initial constants K
var K = []uint32{
	0x428a2f98,
	0x71374491,
	0xb5c0fbcf,
	0xe9b5dba5,
	0x3956c25b,
	0x59f111f1,
	0x923f82a4,
	0xab1c5ed5,
	0xd807aa98,
	0x12835b01,
	0x243185be,
	0x550c7dc3,
	0x72be5d74,
	0x80deb1fe,
	0x9bdc06a7,
	0xc19bf174,
	0xe49b69c1,
	0xefbe4786,
	0x0fc19dc6,
	0x240ca1cc,
	0x2de92c6f,
	0x4a7484aa,
	0x5cb0a9dc,
	0x76f988da,
	0x983e5152,
	0xa831c66d,
	0xb00327c8,
	0xbf597fc7,
	0xc6e00bf3,
	0xd5a79147,
	0x06ca6351,
	0x14292967,
	0x27b70a85,
	0x2e1b2138,
	0x4d2c6dfc,
	0x53380d13,
	0x650a7354,
	0x766a0abb,
	0x81c2c92e,
	0x92722c85,
	0xa2bfe8a1,
	0xa81a664b,
	0xc24b8b70,
	0xc76c51a3,
	0xd192e819,
	0xd6990624,
	0xf40e3585,
	0x106aa070,
	0x19a4c116,
	0x1e376c08,
	0x2748774c,
	0x34b0bcb5,
	0x391c0cb3,
	0x4ed8aa4a,
	0x5b9cca4f,
	0x682e6ff3,
	0x748f82ee,
	0x78a5636f,
	0x84c87814,
	0x8cc70208,
	0x90befffa,
	0xa4506ceb,
	0xbef9a3f7,
	0xc67178f2,
}

// initial hash value H
var H = []uint32{
	0x6a09e667,
	0xbb67ae85,
	0x3c6ef372,
	0xa54ff53a,
	0x510e527f,
	0x9b05688c,
	0x1f83d9ab,
	0x5be0cd19,
}

// Ch ...
func Ch(x, y, z uint32) uint32 {
	return (x & y) ^ ((^x) & z)
}

// Maj ...
func Maj(x, y, z uint32) uint32 {
	return (x & y) ^ (x & z) ^ (y & z)
}

// ROTR ...
func ROTR(x uint32, n uint) uint32 {
	return (x >> n) | (x << (32 - n))
}

// SHR ...
func SHR(x uint32, n uint) uint32 {
	return x >> n
}

// LargeSigma0 ...
func LargeSigma0(x uint32) uint32 {
	return ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)
}

// LargeSigma1 ...
func LargeSigma1(x uint32) uint32 {
	return ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)
}

// SmallSigma0 ...
func SmallSigma0(x uint32) uint32 {
	return ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)
}

// SmallSigma1 ...
func SmallSigma1(x uint32) uint32 {
	return ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10)
}

// Padding ...
func Padding(message []byte) []byte {
	l := len(message)
	if l%64 < 56 {
		newlen := l % 64
		message = append(message[:], []byte{0x80}...)
		zero := make([]byte, 56-(newlen+1))
		message = append(message[:], zero[:]...)
		fmt.Println(message)
		fmt.Printf("length(bit):%v length(byte):%v\n", len(message), len(message)*8)
		ms := make([]byte, 8)
		binary.BigEndian.PutUint64(ms, uint64(l*8))
		message = append(message[:], ms[:]...)
	} else {
		message = append(message[:], []byte{0x80}...)
		newlen := l%64 + 1
		zero := make([]byte, 120-newlen)
		message = append(message[:], zero[:]...)
		bs := make([]byte, 8)
		binary.BigEndian.PutUint64(bs, uint64(l*8))
		message = append(message[:], bs[:]...)
	}
	return message
}

// Parse ...
func Parse(message []byte) [][16]uint32 {
	M := make([][16]uint32, len(message)/64)
	for i := 0; i < len(message)/64; i++ {
		for j := 0; j < 16; j++ {
			M[i][j] = uint32(message[64*i+j*4+3]) | uint32(message[64*i+j*4+2])<<8 | uint32(message[64*i+j*4+1])<<16 | uint32(message[64*i+j*4])<<24
		}
	}
	return M
}

// HashComp ...
func HashComp(M [][16]uint32) string {
	W := [64]uint32{}
	for _, m := range M {
		a := H[0]
		b := H[1]
		c := H[2]
		d := H[3]
		e := H[4]
		f := H[5]
		g := H[6]
		h := H[7]
		for t := 0; t < 64; t++ {
			if 0 <= t && t <= 15 {
				W[t] = m[t]
			} else if 16 <= t && t <= 63 {
				W[t] = SmallSigma1(W[t-2]) + W[t-7] + SmallSigma0(W[t-15]) + W[t-16]
			}
		}

		for t := 0; t < 64; t++ {
			T1 := h + LargeSigma1(e) + Ch(e, f, g) + K[t] + W[t]
			T2 := LargeSigma0(a) + Maj(a, b, c)
			h = g
			g = f
			f = e
			e = d + T1
			d = c
			c = b
			b = a
			a = T1 + T2
		}
		H[0] = a + H[0]
		H[1] = b + H[1]
		H[2] = c + H[2]
		H[3] = d + H[3]
		H[4] = e + H[4]
		H[5] = f + H[5]
		H[6] = g + H[6]
		H[7] = h + H[7]
		fmt.Println(H)
	}

	var hash string
	for _, s := range H {
		hash += fmt.Sprintf("%x", s)
	}

	return hash
}

// Sum256 ...
func Sum256(data []byte) string {
	padData := Padding(data)
	parsedData := Parse(padData)
	return HashComp(parsedData)
}

func main() {
	data := []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") // 64byte

	fmt.Printf("SHA-256 : %s\n", Sum256(data))
	fmt.Printf("SHA-256 : %x\n", sha256.Sum256(data))
}