Go BLAKE2 Hash Code Example (Online Runner)

Go BLAKE2 hashing examples for BLAKE2b/BLAKE2s with keyed mode and digest length controls.

Online calculator: use the site BLAKE2 text tool.

Note: This snippet requires locally installed dependencies and will not run in the online runner. Run it locally with: go mod init blake2-demo && go get golang.org/x/crypto/blake2b && go run blake2_basic.go

Calculation method

Use golang.org/x/crypto/blake2b (64-byte digest) or golang.org/x/crypto/blake2s (32-byte digest) with optional digest size and key.

Implementation notes

Package: golang.org/x/crypto/blake2b and golang.org/x/crypto/blake2s.
Implementation: digest size controls output length; keys enable MAC mode.
Notes: keyed BLAKE2 is a MAC; key length is limited to the digest size.

Text hashing example

package main

import (
	"encoding/hex"
	"fmt"

	"golang.org/x/crypto/blake2b"
)

func blake2bText(text string) string {
	sum := blake2b.Sum512([]byte(text))
	return hex.EncodeToString(sum[:])
}

func main() {
	fmt.Println(blake2bText("hello world"))
}

File hashing example

package main

import (
	"encoding/hex"
	"fmt"
	"io"
	"os"

	"golang.org/x/crypto/blake2b"
)

func blake2bFile(path string) (string, error) {
	file, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer file.Close()

	hash, err := blake2b.New512(nil)
	if err != nil {
		return "", err
	}
	if _, err := io.Copy(hash, file); err != nil {
		return "", err
	}
	return hex.EncodeToString(hash.Sum(nil)), nil
}

func main() {
	file, err := os.CreateTemp("", "blake2-example-*.bin")
	if err != nil {
		panic(err)
	}
	defer os.Remove(file.Name())
	file.WriteString("example payload\n")
	file.Close()

	value, err := blake2bFile(file.Name())
	if err != nil {
		panic(err)
	}
	fmt.Println(value)
}

Complete script (implementation + tests)

package main

import (
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"os"

	"golang.org/x/crypto/blake2b"
	"golang.org/x/crypto/blake2s"
)

type Variant string

const (
	BLAKE2b Variant = "blake2b"
	BLAKE2s Variant = "blake2s"
)

func blake2Hasher(variant Variant, digestSize int, key []byte) (func() []byte, io.Writer, error) {
	switch variant {
	case BLAKE2b:
		if digestSize == 0 {
			digestSize = 64
		}
		h, err := blake2b.New(digestSize, key)
		if err != nil {
			return nil, nil, err
		}
		return func() []byte { return h.Sum(nil) }, h, nil
	case BLAKE2s:
		if digestSize == 0 {
			digestSize = 32
		}
		switch digestSize {
		case 32:
			h, err := blake2s.New256(key)
			if err != nil {
				return nil, nil, err
			}
			return func() []byte { return h.Sum(nil) }, h, nil
		case 16:
			h, err := blake2s.New128(key)
			if err != nil {
				return nil, nil, err
			}
			return func() []byte { return h.Sum(nil) }, h, nil
		default:
			return nil, nil, errors.New("unsupported blake2s digest size")
		}
	default:
		return nil, nil, errors.New("unsupported variant")
	}
}

func blake2Text(text string, variant Variant, digestSize int, key string) (string, error) {
	var keyBytes []byte
	if key != "" {
		keyBytes = []byte(key)
	}
	sumFn, hasher, err := blake2Hasher(variant, digestSize, keyBytes)
	if err != nil {
		return "", err
	}
	hasher.Write([]byte(text))
	return hex.EncodeToString(sumFn()), nil
}

func blake2File(path string, variant Variant, digestSize int, key string) (string, error) {
	var keyBytes []byte
	if key != "" {
		keyBytes = []byte(key)
	}
	sumFn, hasher, err := blake2Hasher(variant, digestSize, keyBytes)
	if err != nil {
		return "", err
	}
	file, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer file.Close()
	if _, err := io.Copy(hasher, file); err != nil {
		return "", err
	}
	return hex.EncodeToString(sumFn()), nil
}

func main() {
	value, err := blake2Text("hello", BLAKE2b, 0, "")
	if err != nil {
		panic(err)
	}
	fmt.Println("blake2b=", value)

	valueKeyed, err := blake2Text("hello", BLAKE2s, 16, "secret")
	if err != nil {
		panic(err)
	}
	fmt.Println("blake2s keyed=", valueKeyed)

	file, err := os.CreateTemp("", "blake2-example-*.bin")
	if err != nil {
		panic(err)
	}
	defer os.Remove(file.Name())
	file.WriteString("example payload\n")
	file.Close()

	fileHash, err := blake2File(file.Name(), BLAKE2b, 0, "")
	if err != nil {
		panic(err)
	}
	fmt.Println("blake2b(file)=", fileHash)
}