// Initialize manifest from BLOB
func (s *Manifest) ParseBlob(in io.Reader, chunkSize int64) (err error) {
var chunkHasher hash.Hash
var w io.Writer
var chunk Chunk
hasher := sha3.New256()
var written int64
for {
chunk = Chunk{
Offset: s.Size,
}
chunkHasher = sha3.New256()
w = io.MultiWriter(hasher, chunkHasher)
written, err = io.CopyN(w, in, chunkSize)
s.Size += written
chunk.Size = written
chunk.ID = ID(hex.EncodeToString(chunkHasher.Sum(nil)))
s.Chunks = append(s.Chunks, chunk)
if err == io.EOF {
err = nil
break
} else if err != nil {
return
}
}
s.ID = ID(hex.EncodeToString(hasher.Sum(nil)))
return
}
func Test_SHA3(t *testing.T) {
hasher1 := sha3.New256()
hasher1.Write([]byte("mama_myla_ramu"))
hasher2 := sha3.New256()
hasher2.Write([]byte("mama_"))
hasher2.Write([]byte("myla_"))
hasher2.Write([]byte("ramu"))
assert.Equal(t, hasher1.Sum(nil), hasher2.Sum(nil))
}
func (s *BlockStorage) getCAFile(name string) (w *contentaddressable.File, err error) {
caOpts := contentaddressable.DefaultOptions()
caOpts.Hasher = sha3.New256()
w, err = contentaddressable.NewFileWithOptions(name, caOpts)
return
}
// Checksum returns the checksum of some data, using a specified algorithm.
// It only returns an error when an invalid algorithm is used. The valid ones
// are MD5, SHA1, SHA224, SHA256, SHA384, SHA512, SHA3224, SHA3256, SHA3384,
// and SHA3512.
func Checksum(algorithm string, data []byte) (checksum string, err error) {
// default
var hasher hash.Hash
switch strings.ToUpper(algorithm) {
case "MD5":
hasher = md5.New()
case "SHA1":
hasher = sha1.New()
case "SHA224":
hasher = sha256.New224()
case "SHA256":
hasher = sha256.New()
case "SHA384":
hasher = sha512.New384()
case "SHA512":
hasher = sha512.New()
case "SHA3224":
hasher = sha3.New224()
case "SHA3256":
hasher = sha3.New256()
case "SHA3384":
hasher = sha3.New384()
case "SHA3512":
hasher = sha3.New512()
default:
msg := "Invalid algorithm parameter passed go Checksum: %s"
return checksum, fmt.Errorf(msg, algorithm)
}
hasher.Write(data)
str := hex.EncodeToString(hasher.Sum(nil))
return str, nil
}
func (u *U16x16) PutData3(data []byte, key string) (length int64, hash string, err error) {
s := sha3.New256()
s.Write(data)
hash = hex.EncodeToString(s.Sum(nil))
if hash != key {
fmt.Printf("expected data to have key %s, but content key is %s",
key, hash)
err = errors.New("content/key mismatch")
return
}
length = int64(len(data))
topSubDir := hash[0:1]
lowerDir := hash[1:2]
targetDir := filepath.Join(u.path, topSubDir, lowerDir)
found, err := xf.PathExists(targetDir)
if err == nil && !found {
err = os.MkdirAll(targetDir, 0775)
}
fullishPath := filepath.Join(targetDir, key[2:])
found, err = xf.PathExists(fullishPath)
if !found {
var dest *os.File
dest, err = os.Create(fullishPath)
if err == nil {
var count int
defer dest.Close()
count, err = dest.Write(data)
if err == nil {
length = int64(count)
}
}
}
return
}
func (u *UFlat) PutData3(data []byte, key string) (length int64, hash string, err error) {
s := sha3.New256()
s.Write(data)
hash = hex.EncodeToString(s.Sum(nil))
if hash != key {
fmt.Printf("expected data to have key %s, but content key is %s",
key, hash)
err = errors.New("content/key mismatch")
return
}
length = int64(len(data))
fullishPath := filepath.Join(u.path, key)
found, err := xf.PathExists(fullishPath)
if !found {
var dest *os.File
dest, err = os.Create(fullishPath)
if err == nil {
var count int
defer dest.Close()
count, err = dest.Write(data)
if err == nil {
length = int64(count)
}
}
}
return
}
func Test_Assembler_StoreChunk(t *testing.T) {
wd, _ := os.Getwd()
wd = filepath.Join(wd, "testdata", "assembler-StoreChunk")
m, err := model.New(wd, false, proto.CHUNK_SIZE, 128)
assert.NoError(t, err)
data := []byte("mama myla ramu")
hasher := sha3.New256()
_, err = hasher.Write([]byte(data))
id := proto.ID(hex.EncodeToString(hasher.Sum(nil)))
a, err := model.NewAssembler(m)
assert.NoError(t, err)
defer a.Close()
err = a.StoreChunk(bytes.NewReader(data), id)
assert.NoError(t, err)
// check stored chunk
f, err := os.Open(filepath.Join(a.Where, id.String()))
assert.NoError(t, err)
defer f.Close()
defer os.Remove(filepath.Join(a.Where, id.String()))
r2, err := ioutil.ReadAll(f)
assert.NoError(t, err)
assert.Equal(t, data, r2)
}
func (s *XLSuite) verifyLeafSHA(c *C, rng *xr.PRNG,
node MerkleNodeI, pathToFile string, whichSHA int) {
c.Assert(node.IsLeaf(), Equals, true)
found, err := xf.PathExists(pathToFile)
c.Assert(err, IsNil)
c.Assert(found, Equals, true)
data, err := ioutil.ReadFile(pathToFile)
c.Assert(err, IsNil)
c.Assert(data, NotNil)
var sha hash.Hash
switch whichSHA {
case xu.USING_SHA1:
sha = sha1.New()
case xu.USING_SHA2:
sha = sha256.New()
case xu.USING_SHA3:
sha = sha3.New256()
// XXX DEFAULT = ERROR
}
sha.Write(data)
sum := sha.Sum(nil)
c.Assert(node.GetHash(), DeepEquals, sum)
}
// Store chunk in assemble
func (a *Assembler) StoreChunk(r io.Reader, id proto.ID) (err error) {
lock, err := a.model.FdLocks.Take()
if err != nil {
return
}
defer lock.Release()
caOpts := contentaddressable.DefaultOptions()
caOpts.Hasher = sha3.New256()
w, err := contentaddressable.NewFileWithOptions(
filepath.Join(a.Where, id.String()), caOpts)
if os.IsExist(err) {
err = nil
return
}
if err != nil {
return
}
defer w.Close()
if _, err = io.Copy(w, r); err != nil {
return
}
err = w.Accept()
return
}
// Checks the signature against
// the message
func SchnorrVerify(suite abstract.Suite,
kp SchnorrPublicKey,
msg []byte, sig []byte) (bool, error) {
buf := bytes.NewBuffer(sig)
signature := SchnorrSignature{}
err := abstract.Read(buf, &signature, suite)
if err != nil {
return false, err
}
s := signature.S
e := signature.E
var gs, ye, r abstract.Point
gs = suite.Point().Mul(nil, s) // g^s
ye = suite.Point().Mul(kp.Y, e) // y^e
r = suite.Point().Add(gs, ye) // g^xy^e
r_bin, _ := r.MarshalBinary()
msg_and_r := append(msg, r_bin...)
hasher := sha3.New256()
hasher.Write(msg_and_r)
h := hasher.Sum(nil)
// again I'm hoping this just reads the state out
// and doesn't actually perform any ops
lct := suite.Cipher(h)
ev := suite.Secret().Pick(lct)
return ev.Equal(e), nil
}
/* GenerateZ takes some random agreed information and creates
Z the "public-only" key that is witness-independent as per
the paper. We've probably broken that slightly in this implementation
because I could not pick a point without generating it
via a Secret, instead of directly via a Point - that is, even as a
32-byte string, we cannot decode on C25519 (and this wouldn't work
for abstract suites anyway).
However, it demonstrates the idea.
*/
func GenerateZ(suite abstract.Suite, info []byte) (abstract.Point, error) {
hasher := sha3.New256()
hasher.Write(info)
zraw := hasher.Sum(nil)
//I think this might be cheating
zrawCt := suite.Cipher(zraw)
zfactor := suite.Secret().Pick(zrawCt)
Z := suite.Point()
Z.Mul(nil, zfactor)
// every 32-bit integer exists on Curve25519 only if we have the fullgroup
// this should work, but doesn't.
/*var Z abstract.Point
zrawBuf := bytes.NewBuffer(zraw)
err := abstract.Read(zrawBuf, &Z, suite);
if err != nil {
return nil, err
}*/
return Z, nil
}
func TestHashOpts(t *testing.T) {
msg := []byte("abcd")
// SHA256
digest1, err := currentBCCSP.Hash(msg, &bccsp.SHA256Opts{})
if err != nil {
t.Fatalf("Failed computing SHA256 [%s]", err)
}
h := sha256.New()
h.Write(msg)
digest2 := h.Sum(nil)
if !bytes.Equal(digest1, digest2) {
t.Fatalf("Different SHA256 computed. [%x][%x]", digest1, digest2)
}
// SHA384
digest1, err = currentBCCSP.Hash(msg, &bccsp.SHA384Opts{})
if err != nil {
t.Fatalf("Failed computing SHA384 [%s]", err)
}
h = sha512.New384()
h.Write(msg)
digest2 = h.Sum(nil)
if !bytes.Equal(digest1, digest2) {
t.Fatalf("Different SHA384 computed. [%x][%x]", digest1, digest2)
}
// SHA3_256O
digest1, err = currentBCCSP.Hash(msg, &bccsp.SHA3_256Opts{})
if err != nil {
t.Fatalf("Failed computing SHA3_256 [%s]", err)
}
h = sha3.New256()
h.Write(msg)
digest2 = h.Sum(nil)
if !bytes.Equal(digest1, digest2) {
t.Fatalf("Different SHA3_256 computed. [%x][%x]", digest1, digest2)
}
// SHA3_384
digest1, err = currentBCCSP.Hash(msg, &bccsp.SHA3_384Opts{})
if err != nil {
t.Fatalf("Failed computing SHA3_384 [%s]", err)
}
h = sha3.New384()
h.Write(msg)
digest2 = h.Sum(nil)
if !bytes.Equal(digest1, digest2) {
t.Fatalf("Different SHA3_384 computed. [%x][%x]", digest1, digest2)
}
}
func (d *XLSuite) TestXLatticePkt(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_XLATTICE_PKT")
}
rng := xr.MakeSimpleRNG()
myMsgN := uint64(rng.Int63())
for myMsgN == 0 { // must not be zero
myMsgN = uint64(rng.Int63())
}
id := make([]byte, 32) // sha3 length
rng.NextBytes(id) // random bytes
seqBuf := new(bytes.Buffer)
binary.Write(seqBuf, binary.LittleEndian, myMsgN)
msgLen := 64 + rng.Intn(64)
msg := make([]byte, msgLen)
rng.NextBytes(msg) // fill with rubbish
salt := make([]byte, 8)
rng.NextBytes(salt) // still more rubbish
digest := sha3.New256()
digest.Write(id)
digest.Write(seqBuf.Bytes())
digest.Write(msg)
digest.Write([]byte(salt))
hash := digest.Sum(nil)
// XXX This does not adhere to the rules: it has no Cmd field;
// since it has a payload it must be a Put, and so the id is
// also required and the Hash field should be a Sig instead, right?
var pkt = XLatticeMsg{
MsgN: &myMsgN,
Payload: msg,
Salt: salt,
Hash: hash,
}
// In each of these cases, the test proves that the field
// was present; otherwise the 'empty' value (zero, nil, etc)
// would have been returned.
msgNOut := pkt.GetMsgN()
c.Assert(msgNOut, Equals, myMsgN)
msgOut := pkt.GetPayload()
d.compareByteSlices(c, msgOut, msg)
saltOut := pkt.GetSalt()
d.compareByteSlices(c, saltOut, salt)
hashOut := pkt.GetHash()
d.compareByteSlices(c, hashOut, hash)
}
func createKeyFromPassword(pwd string) ([]byte, error) {
if len(pwd) < 8 {
return nil, fmt.Errorf("Password has to be at least 8 characters")
}
h := sha3.New256()
h.Write([]byte(pwd))
return h.Sum(nil), nil
}
// (Either side) This function takes the aggregate public commitment
// r and returns sha3(m||r) for a given message.
func SchnorrMComputeCollectiveChallenge(suite abstract.Suite,
msg []byte,
pubCommit SchnorrMAggregateCommmitment) []byte {
p_bin, _ := pubCommit.P.MarshalBinary()
msg_and_p := append(msg, p_bin...)
hasher := sha3.New256()
hasher.Write(msg_and_p)
h := hasher.Sum(nil)
return h
}
/* This is the function that given the client's challenge and response from the server is able to
compute the final blind signature. This is done on the user side (blindly to the signer). */
func ClientSignBlindly(suite abstract.Suite, clientParameters WISchnorrClientParamersList, responseMsg WISchnorrResponseMessage, pubKey SchnorrPublicKey, msg []byte) (WIBlindSignature, bool) {
rho := suite.Secret()
omega := suite.Secret()
sigma := suite.Secret()
delta := suite.Secret()
rho.Add(responseMsg.R, clientParameters.T1)
omega.Add(responseMsg.C, clientParameters.T2)
sigma.Add(responseMsg.S, clientParameters.T3)
delta.Add(responseMsg.D, clientParameters.T4)
gp := suite.Point()
gp.Mul(nil, rho)
yw := suite.Point()
yw.Mul(pubKey.Y, omega)
gpyw := suite.Point()
gpyw.Add(gp, yw)
bGpyw, _ := gpyw.MarshalBinary()
gs := suite.Point()
gs.Mul(nil, sigma)
zd := suite.Point()
zd.Mul(clientParameters.Z, delta)
gszd := suite.Point()
gszd.Add(gs, zd)
bGszd, _ := gszd.MarshalBinary()
bZ, _ := clientParameters.Z.MarshalBinary()
var combinedmsg []byte
combinedmsg = append(combinedmsg, bGpyw...)
combinedmsg = append(combinedmsg, bGszd...)
combinedmsg = append(combinedmsg, bZ...)
combinedmsg = append(combinedmsg, msg...)
hasher := sha3.New256()
hasher.Write(combinedmsg)
bSig := hasher.Sum(nil)
bSigCt := suite.Cipher(bSig)
sig := suite.Secret().Pick(bSigCt)
vsig := suite.Secret()
vsig.Add(omega, delta)
//fmt.Println(sig)
//fmt.Println(vsig)
return WIBlindSignature{rho, omega, sigma, delta}, sig.Equal(vsig)
}
func HashSHA3Data(input []byte) (out []byte, err error) {
//sha3hash := sha3.NewKeccak256()
sha3hash := sha3.New256()
_, err = sha3hash.Write(input)
if err != nil {
//return nil, acprotoError(-1, "HashSHA3Data().Write(): ", err)
//return nil, &protoError{value: -1, msg: "HashSHA3Data().Write(): ", err: err}
return nil, &AcError{Value: -1, Msg: "HashSHA3Data().Write(): ", Err: err}
}
out = sha3hash.Sum(nil)
return
}
func makeHash(name string) hash.Hash {
switch strings.ToLower(name) {
case "ripemd160":
return ripemd160.New()
case "md4":
return md4.New()
case "md5":
return md5.New()
case "sha1":
return sha1.New()
case "sha256":
return sha256.New()
case "sha384":
return sha512.New384()
case "sha3-224":
return sha3.New224()
case "sha3-256":
return sha3.New256()
case "sha3-384":
return sha3.New384()
case "sha3-512":
return sha3.New512()
case "sha512":
return sha512.New()
case "sha512-224":
return sha512.New512_224()
case "sha512-256":
return sha512.New512_256()
case "crc32-ieee":
return crc32.NewIEEE()
case "crc64-iso":
return crc64.New(crc64.MakeTable(crc64.ISO))
case "crc64-ecma":
return crc64.New(crc64.MakeTable(crc64.ECMA))
case "adler32":
return adler32.New()
case "fnv32":
return fnv.New32()
case "fnv32a":
return fnv.New32a()
case "fnv64":
return fnv.New64()
case "fnv64a":
return fnv.New64a()
case "xor8":
return new(xor8)
case "fletch16":
return &fletch16{}
}
return nil
}
func Test_Proto_Spec1(t *testing.T) {
m1, err := proto.NewFromManifest(fixtures.CleanInput(`BAR:MANIFEST
id ac934d9a88b42aa3b40ef7c81a9dee1aad5a2cddccb00ae6abab9c38095fc15c
size 1234
id ac934d9a88b42aa3b40ef7c81a9dee1aad5a2cddccb00ae6abab9c38095fc15c
size 1234
offset 0
`))
assert.NoError(t, err)
m2, err := proto.NewFromManifest(fixtures.CleanInput(`BAR:MANIFEST
id ac934d9a88b42aa3b40ef7c81a9dee1aad5a2cddccb00ae6abab9c38095fc15c
size 1234
id ac934d9a88b42aa3b40ef7c81a9dee1aad5a2cddccb00ae6abab9c38095fc15c
size 1234
offset 0
`))
assert.NoError(t, err)
spec, err := proto.NewSpec(time.Now().UnixNano(), map[string]proto.ID{
"file/1": m1.ID,
"file/2": m2.ID,
}, []string{})
// hand-made fixture
var sorted sort.StringSlice
sorted = append(sorted, "file/2")
sorted = append(sorted, "file/1")
sorted.Sort()
hasher := sha3.New256()
var id []byte
err = m1.ID.Decode(id)
assert.NoError(t, err)
_, err = hasher.Write([]byte(sorted[0]))
_, err = hasher.Write(id)
_, err = hasher.Write([]byte(sorted[1]))
_, err = hasher.Write(id)
assert.Equal(t, spec.ID, proto.ID(hex.EncodeToString(hasher.Sum(nil))))
}
func main() {
flag.Parse()
hashAlgorithm := sha1.New()
if *sha1Flag {
hashAlgorithm = sha1.New()
}
if *md5Flag {
hashAlgorithm = md5.New()
}
if *sha256Flag {
hashAlgorithm = sha256.New()
}
if *sha384Flag {
hashAlgorithm = sha512.New384()
}
if *sha3256Flag {
hashAlgorithm = sha3.New256()
}
if *sha3384Flag {
hashAlgorithm = sha3.New384()
}
if *sha3512Flag {
hashAlgorithm = sha3.New512()
}
if *whirlpoolFlag {
hashAlgorithm = whirlpool.New()
}
if *blakeFlag {
hashAlgorithm = blake2.NewBlake2B()
}
if *ripemd160Flag {
hashAlgorithm = ripemd160.New()
}
for _, fileName := range flag.Args() {
f, _ := os.Open(fileName)
defer f.Close()
hashAlgorithm.Reset()
output := genericHashFile(f, hashAlgorithm)
if *b64Flag {
r64Output := base64.StdEncoding.EncodeToString(output)
fmt.Printf("%s %s\n", r64Output, fileName)
} else {
fmt.Printf("%x %s\n", output, fileName)
}
}
}
func getHashSHA3(bitsize int) (hash.Hash, error) {
switch bitsize {
case 224:
return sha3.New224(), nil
case 256:
return sha3.New256(), nil
case 384:
return sha3.New384(), nil
case 512:
return sha3.New512(), nil
case 521:
return sha3.New512(), nil
default:
return nil, fmt.Errorf("Invalid bitsize. It was [%d]. Expected [224, 256, 384, 512, 521]", bitsize)
}
}
func SHA3File(pathToFile string) (hash []byte, err error) {
var data []byte
found, err := xf.PathExists(pathToFile)
if err == nil && !found {
err = FileNotFound
}
if err == nil {
data, err = ioutil.ReadFile(pathToFile)
if err == nil {
digest := sha3.New256()
digest.Write(data)
hash = digest.Sum(nil)
}
}
return
}
func (s *XLSuite) doTestSHA(c *C, rng *xr.PRNG, whichSHA int) {
var hash, fHash []byte
var sHash string
// name guaranteed to be unique
length, pathToFile := rng.NextDataFile("tmp", 1024, 256)
data, err := ioutil.ReadFile(pathToFile)
c.Assert(err, IsNil)
c.Assert(len(data), Equals, length)
parts := strings.Split(pathToFile, "/")
c.Assert(len(parts), Equals, 2)
fileName := parts[1]
switch whichSHA {
case xu.USING_SHA1:
sha := sha1.New()
sha.Write(data)
hash = sha.Sum(nil)
fHash, err = SHA1File(pathToFile)
case xu.USING_SHA2:
sha := sha256.New()
sha.Write(data)
hash = sha.Sum(nil)
fHash, err = SHA2File(pathToFile)
case xu.USING_SHA3:
sha := sha3.New256()
sha.Write(data)
hash = sha.Sum(nil)
fHash, err = SHA3File(pathToFile)
// XXX DEFAULT = ERROR
}
c.Assert(err, IsNil)
c.Assert(bytes.Equal(hash, fHash), Equals, true)
ml, err := CreateMerkleLeafFromFileSystem(pathToFile, fileName, whichSHA)
c.Assert(err, IsNil)
c.Assert(ml.Name(), Equals, fileName)
c.Assert(bytes.Equal(ml.GetHash(), hash), Equals, true)
c.Assert(ml.WhichSHA(), Equals, whichSHA)
// TODO: test ToString
_ = sHash // TODO
}
func TestSHA(t *testing.T) {
for i := 0; i < 100; i++ {
b, err := GetRandomBytes(i)
if err != nil {
t.Fatalf("Failed getting random bytes [%s]", err)
}
h1, err := currentBCCSP.Hash(b, &bccsp.SHAOpts{})
if err != nil {
t.Fatalf("Failed computing SHA [%s]", err)
}
var h hash.Hash
switch currentTestConfig.hashFamily {
case "SHA2":
switch currentTestConfig.securityLevel {
case 256:
h = sha256.New()
case 384:
h = sha512.New384()
default:
t.Fatalf("Invalid security level [%d]", currentTestConfig.securityLevel)
}
case "SHA3":
switch currentTestConfig.securityLevel {
case 256:
h = sha3.New256()
case 384:
h = sha3.New384()
default:
t.Fatalf("Invalid security level [%d]", currentTestConfig.securityLevel)
}
default:
t.Fatalf("Invalid hash family [%s]", currentTestConfig.hashFamily)
}
h.Write(b)
h2 := h.Sum(nil)
if !bytes.Equal(h1, h2) {
t.Fatalf("Discrempancy found in HASH result [%x], [%x]!=[%x]", b, h1, h2)
}
}
}
// returns the SHA3 hash of the contents of a file
func FileBinSHA3(path string) (binHash []byte, err error) {
var data2 []byte
binHash = xu.SHA3_BIN_NONE
found, err := xf.PathExists(path)
if err == nil && !found {
err = errors.New("IllegalArgument: empty path or non-existent file")
}
if err == nil {
data2, err = ioutil.ReadFile(path)
}
if err == nil {
d2 := sha3.New256()
d2.Write(data2)
binHash = d2.Sum(nil)
}
return
}
func NewSpec(timestamp int64, in map[string]ID, kill []string) (res Spec, err error) {
hasher := sha3.New256()
var idBuf []byte
var names sort.StringSlice
for n, _ := range in {
names = append(names, n)
}
sort.Sort(names)
kills := sort.StringSlice(kill)
kills.Sort()
drop := map[string]ID{}
var removalsDrop []string
for _, n := range names {
if _, err = hasher.Write([]byte(filepath.ToSlash(n))); err != nil {
return
}
if err = in[n].Decode(idBuf); err != nil {
return
}
if _, err = hasher.Write(idBuf); err != nil {
return
}
drop[filepath.ToSlash(n)] = in[n]
}
for _, n := range kills {
if _, err = hasher.Write([]byte(filepath.ToSlash(n))); err != nil {
return
}
removalsDrop = append(removalsDrop, filepath.ToSlash(n))
}
res = Spec{
ID(hex.EncodeToString(hasher.Sum(nil))),
timestamp,
drop,
removalsDrop}
return
}
func (s *XLSuite) verifyTreeSHA(c *C, rng *xr.PRNG,
n MerkleNodeI, pathToNode string, whichSHA int) {
c.Assert(n.IsLeaf(), Equals, false)
node := n.(*MerkleTree)
if node.nodes == nil {
c.Assert(node.GetHash(), Equals, nil)
} else {
hashCount := 0
var sha hash.Hash
switch whichSHA {
case xu.USING_SHA1:
sha = sha1.New()
case xu.USING_SHA2:
sha = sha256.New()
case xu.USING_SHA3:
sha = sha3.New256()
// XXX DEFAULT = ERROR
}
for i := 0; i < len(node.nodes); i++ {
n := node.nodes[i]
pathToFile := path.Join(pathToNode, n.Name())
if n.IsLeaf() {
s.verifyLeafSHA(c, rng, n, pathToFile, whichSHA)
} else if !n.IsLeaf() {
s.verifyTreeSHA(c, rng, n, pathToFile, whichSHA)
} else {
c.Error("unknown node type!")
}
if n.GetHash() != nil {
hashCount += 1
sha.Write(n.GetHash())
}
}
if hashCount == 0 {
c.Assert(node.GetHash(), IsNil)
} else {
c.Assert(node.GetHash(), DeepEquals, sha.Sum(nil))
}
}
}
// GetHash returns and instance of hash.Hash using options opts.
// If opts is nil then the default hash function is returned.
func (csp *impl) GetHash(opts bccsp.HashOpts) (h hash.Hash, err error) {
if opts == nil {
return csp.conf.hashFunction(), nil
}
switch opts.(type) {
case *bccsp.SHAOpts:
return csp.conf.hashFunction(), nil
case *bccsp.SHA256Opts:
return sha256.New(), nil
case *bccsp.SHA384Opts:
return sha512.New384(), nil
case *bccsp.SHA3_256Opts:
return sha3.New256(), nil
case *bccsp.SHA3_384Opts:
return sha3.New384(), nil
default:
return nil, fmt.Errorf("Algorithm not recognized [%s]", opts.Algorithm())
}
}
func computeHash(msg []byte, bitsize int) ([]byte, error) {
var hash hash.Hash
switch bitsize {
case 224:
hash = sha3.New224()
case 256:
hash = sha3.New256()
case 384:
hash = sha3.New384()
case 512:
hash = sha3.New512()
case 521:
hash = sha3.New512()
default:
return nil, fmt.Errorf("Invalid bitsize. It was [%d]. Expected [224, 256, 384, 512, 521]", bitsize)
}
hash.Write(msg)
return hash.Sum(nil), nil
}
func (md *MerkleDoc) SetTree(tree *MerkleTree) (err error) {
if tree == nil {
err = NilTree
} else {
var digest hash.Hash
switch md.whichSHA {
case xu.USING_SHA1:
digest = sha1.New()
case xu.USING_SHA2:
digest = sha256.New()
case xu.USING_SHA3:
digest = sha3.New256()
// XXX DEFAULT = ERROR
}
digest.Write(tree.hash)
digest.Write([]byte(md.path))
md.tree = tree
md.hash = digest.Sum(nil)
}
return
}