Skip to content

Commit

Permalink
reorder some functions and get 100% coverage
Browse files Browse the repository at this point in the history
  • Loading branch information
@lukechampine
lukechampine committed Jan 12, 2020
1 parent 633f7e1 commit 70299b9
Show file tree
Hide file tree
Showing 2 changed files with 134 additions and 86 deletions.
178 changes: 92 additions & 86 deletions blake3.go
View file
Expand Up @@ -154,71 +154,6 @@ func (n node) chainingValue() (cv [8]uint32) {
return
}

// An OutputReader produces an seekable stream of 2^64 - 1 pseudorandom output
// bytes.
type OutputReader struct {
n node
block [blockSize]byte
off uint64
}

// Read implements io.Reader. Callers may assume that Read returns len(p), nil
// unless the read would extend beyond the end of the stream.
func (or *OutputReader) Read(p []byte) (int, error) {
if or.off == math.MaxUint64 {
return 0, io.EOF
} else if rem := math.MaxUint64 - or.off; uint64(len(p)) > rem {
p = p[:rem]
}
lenp := len(p)
for len(p) > 0 {
if or.off%blockSize == 0 {
or.n.counter = or.off / blockSize
words := or.n.compress()
wordsToBytes(words[:], or.block[:])
}

n := copy(p, or.block[or.off%blockSize:])
p = p[n:]
or.off += uint64(n)
}
return lenp, nil
}

// Seek implements io.Seeker.
func (or *OutputReader) Seek(offset int64, whence int) (int64, error) {
off := or.off
switch whence {
case io.SeekStart:
if offset < 0 {
return 0, errors.New("seek position cannot be negative")
}
off = uint64(offset)
case io.SeekCurrent:
if offset < 0 {
if uint64(-offset) > off {
return 0, errors.New("seek position cannot be negative")
}
off -= uint64(-offset)
} else {
off += uint64(offset)
}
case io.SeekEnd:
off = uint64(offset) - 1
default:
panic("invalid whence")
}
or.off = off
or.n.counter = uint64(off) / blockSize
if or.off%blockSize != 0 {
words := or.n.compress()
wordsToBytes(words[:], or.block[:])
}
// NOTE: or.off >= 2^63 will result in a negative return value.
// Nothing we can do about this.
return int64(or.off), nil
}

// chunkState manages the state involved in hashing a single chunk of input.
type chunkState struct {
n node
Expand All @@ -233,6 +168,12 @@ func (cs *chunkState) chunkCounter() uint64 {
return cs.n.counter
}

// complete is a helper method that reports whether a full chunk has been
// processed.
func (cs *chunkState) complete() bool {
return cs.bytesConsumed == chunkSize
}

// update incorporates input into the chunkState.
func (cs *chunkState) update(input []byte) {
for len(input) > 0 {
Expand Down Expand Up @@ -311,26 +252,6 @@ type Hasher struct {
size int // output size, for Sum
}

func newHasher(key [8]uint32, flags uint32, size int) *Hasher {
return &Hasher{
cs: newChunkState(key, 0, flags),
key: key,
flags: flags,
size: size,
}
}

// New returns a Hasher for the specified size and key. If key is nil, the hash
// is unkeyed.
func New(size int, key []byte) *Hasher {
if key == nil {
return newHasher(iv, 0, size)
}
var keyWords [8]uint32
bytesToWords(key[:], keyWords[:])
return newHasher(keyWords, flagKeyedHash, size)
}

// addChunkChainingValue appends a chunk to the right edge of the Merkle tree.
func (h *Hasher) addChunkChainingValue(cv [8]uint32, totalChunks uint64) {
// This chunk might complete some subtrees. For each completed subtree, its
Expand Down Expand Up @@ -383,7 +304,7 @@ func (h *Hasher) Write(p []byte) (int, error) {
// If the current chunk is complete, finalize it and add it to the tree,
// then reset the chunk state (but keep incrementing the counter across
// chunks).
if h.cs.bytesConsumed == chunkSize {
if h.cs.complete() {
cv := h.cs.node().chainingValue()
totalChunks := h.cs.chunkCounter() + 1
h.addChunkChainingValue(cv, totalChunks)
Expand Down Expand Up @@ -423,6 +344,26 @@ func (h *Hasher) XOF() *OutputReader {
}
}

func newHasher(key [8]uint32, flags uint32, size int) *Hasher {
return &Hasher{
cs: newChunkState(key, 0, flags),
key: key,
flags: flags,
size: size,
}
}

// New returns a Hasher for the specified size and key. If key is nil, the hash
// is unkeyed.
func New(size int, key []byte) *Hasher {
if key == nil {
return newHasher(iv, 0, size)
}
var keyWords [8]uint32
bytesToWords(key[:], keyWords[:])
return newHasher(keyWords, flagKeyedHash, size)
}

// Sum256 returns the unkeyed BLAKE3 hash of b, truncated to 256 bits.
func Sum256(b []byte) (out [32]byte) {
h := newHasher(iv, 0, 0)
Expand Down Expand Up @@ -463,5 +404,70 @@ func DeriveKey(subKey []byte, ctx string, srcKey []byte) {
h.XOF().Read(subKey)
}

// An OutputReader produces an seekable stream of 2^64 - 1 pseudorandom output
// bytes.
type OutputReader struct {
n node
block [blockSize]byte
off uint64
}

// Read implements io.Reader. Callers may assume that Read returns len(p), nil
// unless the read would extend beyond the end of the stream.
func (or *OutputReader) Read(p []byte) (int, error) {
if or.off == math.MaxUint64 {
return 0, io.EOF
} else if rem := math.MaxUint64 - or.off; uint64(len(p)) > rem {
p = p[:rem]
}
lenp := len(p)
for len(p) > 0 {
if or.off%blockSize == 0 {
or.n.counter = or.off / blockSize
words := or.n.compress()
wordsToBytes(words[:], or.block[:])
}

n := copy(p, or.block[or.off%blockSize:])
p = p[n:]
or.off += uint64(n)
}
return lenp, nil
}

// Seek implements io.Seeker.
func (or *OutputReader) Seek(offset int64, whence int) (int64, error) {
off := or.off
switch whence {
case io.SeekStart:
if offset < 0 {
return 0, errors.New("seek position cannot be negative")
}
off = uint64(offset)
case io.SeekCurrent:
if offset < 0 {
if uint64(-offset) > off {
return 0, errors.New("seek position cannot be negative")
}
off -= uint64(-offset)
} else {
off += uint64(offset)
}
case io.SeekEnd:
off = uint64(offset) - 1
default:
panic("invalid whence")
}
or.off = off
or.n.counter = uint64(off) / blockSize
if or.off%blockSize != 0 {
words := or.n.compress()
wordsToBytes(words[:], or.block[:])
}
// NOTE: or.off >= 2^63 will result in a negative return value.
// Nothing we can do about this.
return int64(or.off), nil
}

// ensure that Hasher implements hash.Hash
var _ hash.Hash = (*Hasher)(nil)
42 changes: 42 additions & 0 deletions blake3_test.go
View file
Expand Up @@ -118,6 +118,27 @@ func TestXOF(t *testing.T) {
if n != 0 || err != io.EOF {
t.Errorf("expected (0, EOF) when reading past end of stream, got (%v, %v)", n, err)
}

// test invalid seek offsets
_, err = xof.Seek(-1, io.SeekStart)
if err == nil {
t.Error("expected invalid offset error, got nil")
}
xof.Seek(0, io.SeekStart)
_, err = xof.Seek(-1, io.SeekCurrent)
if err == nil {
t.Error("expected invalid offset error, got nil")
}

// test invalid seek whence
didPanic := func() (p bool) {
defer func() { p = recover() != nil }()
xof.Seek(0, 17)
return
}()
if !didPanic {
t.Error("expected panic when seeking with invalid whence")
}
}

func TestSum(t *testing.T) {
Expand All @@ -142,6 +163,27 @@ func TestSum(t *testing.T) {
}
}

func TestReset(t *testing.T) {
for _, vec := range testVectors.Cases {
in := testInput[:vec.InputLen]

h := blake3.New(32, nil)
h.Write(in)
out1 := h.Sum(nil)
h.Reset()
h.Write(in)
out2 := h.Sum(nil)
if !bytes.Equal(out1, out2) {
t.Error("Reset did not reset Hasher state properly")
}
}

// gotta have 100% test coverage...
if blake3.New(0, nil).BlockSize() != 64 {
t.Error("incorrect block size")
}
}

type nopReader struct{}

func (nopReader) Read(p []byte) (int, error) { return len(p), nil }
Expand Down

0 comments on commit 70299b9

Please sign in to comment.