Implement bit-oriented SHA-256 family.

Author: tunabay

bitarray_sha256.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2021 Hirotsuna Mizuno. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+package bitarray
+
+import (
+	_ "crypto/sha256" // block()
+	"encoding/binary"
+	_ "unsafe" // linkname
+)
+
+// SHA256 returns the SHA-256 checksum of the bit array. It treats the bit array
+// as a bit-oriented message to compute the checksum as defined in FIPS 180-4.
+func (ba *BitArray) SHA256() (d256 [32]byte) {
+	return ba.sha256CheckSum(false)
+}
+
+// SHA224 returns the SHA-224 checksum of the bit array. It treats the bit array
+// as a bit-oriented message to compute the checksum as defined in FIPS 180-4.
+func (ba *BitArray) SHA224() (d224 [28]byte) {
+	d256 := ba.sha256CheckSum(true)
+	copy(d224[:], d256[:])
+	return
+}
+
+func (ba *BitArray) sha256CheckSum(is224 bool) [32]byte {
+	nBits := ba.Len()
+	buf := NewBuffer((nBits + 1 + 64 + 511) &^ 511)
+	buf.PutBitArrayAt(0, ba)
+	buf.PutBitAt(nBits, 1)
+	binary.BigEndian.PutUint64(buf.b[len(buf.b)-8:], uint64(nBits))
+
+	d := &sha256Digest{is224: is224}
+	sha256Reset(d)
+	sha256Block(d, buf.b)
+
+	n := 8
+	if is224 {
+		n = 7
+	}
+	var d256 [32]byte
+	for i := 0; i < n; i++ {
+		binary.BigEndian.PutUint32(d256[i<<2:], d.h[i])
+	}
+
+	return d256
+}
+
+// crypto/sha256.digest
+// TODO: if possible, use crypto/sha256.digest directly
+type sha256Digest struct {
+	h     [8]uint32
+	x     [64]byte //nolint:structcheck,unused // for Reset()
+	nx    int      //nolint:structcheck,unused // for Reset()
+	len   uint64   //nolint:structcheck,unused // for Reset()
+	is224 bool
+}
+
+//go:linkname sha256Block crypto/sha256.block
+func sha256Block(*sha256Digest, []byte)
+
+//go:linkname sha256Reset crypto/sha256.(*digest).Reset
+func sha256Reset(*sha256Digest)

bitarray_sha256_example_test.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2021 Hirotsuna Mizuno. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+package bitarray_test
+
+import (
+	"fmt"
+
+	"github.com/tunabay/go-bitarray"
+)
+
+func ExampleBitArray_SHA256() {
+	ba1 := bitarray.MustParse("011")
+	ba2 := bitarray.MustParse("010000")
+
+	fmt.Printf("%x\n", ba1.SHA256())
+	fmt.Printf("%x\n", ba2.SHA256())
+
+	// Output:
+	// 1f7794d4b0b67d3a6edcd17aba2144a95828032f7943ed26bf0c7c7628945f48
+	// 5ef0224f79737bda30562831152184b939cc43fcd40d09f4945e081a39c6d542
+}
+
+func ExampleBitArray_SHA224() {
+	ba1 := bitarray.MustParse("10")
+	ba2 := bitarray.MustParse("100")
+
+	fmt.Printf("%x\n", ba1.SHA224())
+	fmt.Printf("%x\n", ba2.SHA224())
+
+	// Output:
+	// ef9c947a47bb9311a0f2b8939cfc12090554868b3b64d8f71e6442f3
+	// 4f2ec61c914dce56c3fe5067aa184125ab126c39edb8bf64f58bdccd
+}

bitarray_sha256_test.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2021 Hirotsuna Mizuno. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+package bitarray_test
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestBitArray_SHA256_cavp(t *testing.T) {
+	test := func(name string) {
+		tcs, err := cavpTestCases(name)
+		if err != nil {
+			t.Fatalf("failed to load test cases: %s: %s", name, err)
+		}
+		for i, tc := range tcs {
+			got := tc.ba.SHA256()
+			if !bytes.Equal(got[:], tc.md) {
+				t.Errorf("unexpected hash: %s: #%d", name, i)
+				t.Logf("mlen: %d", tc.ba.Len())
+				t.Logf(" msg: %#b", tc.ba)
+				t.Logf(" got: %X", got)
+				t.Logf("want: %X", tc.md)
+			}
+		}
+	}
+	test("SHA256ShortMsg")
+	test("SHA256LongMsg")
+}
+
+func TestBitArray_SHA224_cavp(t *testing.T) {
+	test := func(name string) {
+		tcs, err := cavpTestCases(name)
+		if err != nil {
+			t.Fatalf("failed to load test cases: %s: %s", name, err)
+		}
+		for i, tc := range tcs {
+			got := tc.ba.SHA224()
+			if !bytes.Equal(got[:], tc.md) {
+				t.Errorf("unexpected hash: %s: #%d", name, i)
+				t.Logf("mlen: %d", tc.ba.Len())
+				t.Logf(" msg: %#b", tc.ba)
+				t.Logf(" got: %X", got)
+				t.Logf("want: %X", tc.md)
+			}
+		}
+	}
+	test("SHA224ShortMsg")
+	test("SHA224LongMsg")
+}