func BigRandomBlob() *BlobTest {
data := make([]byte, 2097152)
rand.Read(data)
sha := blake2b.New256()
sha.Write(data)
hash := fmt.Sprintf("%x", sha.Sum(nil))
return &BlobTest{hash, data}
}
func NewHash() (h hash.Hash) {
if ih := hashPool.Get(); ih != nil {
h = ih.(hash.Hash)
h.Reset()
} else {
// Creates a new one if the pool is empty
h = blake2b.New256()
}
return
}
func RandomBlob(content []byte) *BlobTest {
var data []byte
if content == nil {
data = make([]byte, 512)
rand.Read(data)
} else {
data = content
}
sha := blake2b.New256()
sha.Write(data)
hash := fmt.Sprintf("%x", sha.Sum(nil))
return &BlobTest{hash, data}
}
func (st *StateTree) Add(h string) {
st.Lock()
defer st.Unlock()
var chash hash.Hash
if exhash, ok := st.level1[h[0:2]]; ok {
chash = exhash
} else {
chash = blake2b.New256()
st.level1[h[0:2]] = chash
}
chash.Write([]byte(h))
st.root.Write([]byte(h))
st.count++
}
// Encode the data, produce AONT package. Data size will be larger than
// the original one for 48 bytes.
func Encode(r *[RSize]byte, in []byte) ([]byte, error) {
out := make([]byte, len(in)+HSize+RSize)
copy(out, in)
h := blake2b.New256()
h.Write(r[:])
h.Write(in)
copy(out[len(in):], h.Sum(nil))
salsaKey := new([32]byte)
copy(salsaKey[:], r[:])
salsa20.XORKeyStream(out, out, dummyNonce, salsaKey)
h.Reset()
h.Write(out[:len(in)+32])
for i, b := range h.Sum(nil)[:RSize] {
out[len(in)+32+i] = b ^ r[i]
}
return out, nil
}
func (backend *BlobsFileBackend) encodeBlob(blob []byte) (size int, data []byte) {
h := blake2b.New256()
h.Write(blob)
if backend.snappyCompression {
dataEncoded := snappy.Encode(nil, blob)
blob = dataEncoded
}
size = len(blob)
data = make([]byte, len(blob)+Overhead)
copy(data[:], h.Sum(nil))
// set the flag
data[hashSize] = 0
binary.LittleEndian.PutUint32(data[hashSize+1:], uint32(size))
copy(data[Overhead:], blob)
return
}
func (backend *BlobsFileBackend) decodeBlob(data []byte) (size int, blob []byte) {
//flag := data[hashSize]
size = int(binary.LittleEndian.Uint32(data[hashSize+1 : Overhead]))
blob = make([]byte, size)
copy(blob, data[Overhead:])
if backend.snappyCompression {
blobDecoded, err := snappy.Decode(nil, blob)
if err != nil {
panic(fmt.Errorf("Failed to decode blob with Snappy: %v", err))
}
blob = blobDecoded
}
h := blake2b.New256()
h.Write(blob)
if !bytes.Equal(h.Sum(nil), data[0:hashSize]) {
panic(fmt.Errorf("Hash doesn't match %x != %x", h.Sum(nil), data[0:hashSize]))
}
return
}
// Decode the data from AONT package. Data size will be smaller than the
// original one for 48 bytes.
func Decode(in []byte) ([]byte, error) {
if len(in) < HSize+RSize {
return nil, errors.New("Too small input buffer")
}
h := blake2b.New256()
h.Write(in[:len(in)-RSize])
salsaKey := new([32]byte)
for i, b := range h.Sum(nil)[:RSize] {
salsaKey[i] = b ^ in[len(in)-RSize+i]
}
h.Reset()
h.Write(salsaKey[:RSize])
out := make([]byte, len(in)-RSize)
salsa20.XORKeyStream(out, in[:len(in)-RSize], dummyNonce, salsaKey)
h.Write(out[:len(out)-HSize])
if subtle.ConstantTimeCompare(h.Sum(nil), out[len(out)-HSize:]) != 1 {
return nil, errors.New("Invalid checksum")
}
return out[:len(out)-HSize], nil
}
func NewStateTree() *StateTree {
return &StateTree{
root: blake2b.New256(),
level1: map[string]hash.Hash{},
}
}
// NewHash returns a blake2b 256bit hasher.
func NewHash() hash.Hash {
return blake2b.New256()
}