func (sn *Node) ComputeCombinedMerkleRoot(view, Round int) {
sn.roundLock.RLock()
round := sn.Rounds[Round]
sn.roundLock.RUnlock()
// add hash of whole log to leaves
round.Leaves = append(round.Leaves, round.HashedLog)
// compute MT root based on Log as right child and
// MT of leaves as left child and send it up to parent
sort.Sort(hashid.ByHashId(round.Leaves))
left, proofs := proof.ProofTree(sn.Suite().Hash, round.Leaves)
right := round.HashedLog
moreLeaves := make([]hashid.HashId, 0)
moreLeaves = append(moreLeaves, left, right)
round.MTRoot, _ = proof.ProofTree(sn.Suite().Hash, moreLeaves)
// Hashed Log has to come first in the proof; len(sn.CMTRoots)+1 proofs
round.Proofs = make(map[string]proof.Proof, 0)
children := sn.Children(view)
for name := range children {
round.Proofs[name] = append(round.Proofs[name], right)
}
round.Proofs["local"] = append(round.Proofs["local"], right)
// separate proofs by children (need to send personalized proofs to children)
// also separate local proof (need to send it to timestamp server)
sn.SeparateProofs(proofs, round.Leaves, Round)
}
func (round *RoundStamper) Commitment(in []*sign.SigningMessage, out *sign.SigningMessage) error {
// compute the local Merkle root
// give up if nothing to process
if len(round.StampQueue) == 0 {
round.StampRoot = make([]byte, hashid.Size)
round.StampProofs = make([]proof.Proof, 1)
} else {
// pull out to be Merkle Tree leaves
round.StampLeaves = make([]hashid.HashId, 0)
for _, msg := range round.StampQueue {
round.StampLeaves = append(round.StampLeaves, hashid.HashId(msg))
}
// create Merkle tree for this round's messages and check corectness
round.StampRoot, round.StampProofs = proof.ProofTree(round.Suite.Hash, round.StampLeaves)
if dbg.DebugVisible > 2 {
if proof.CheckLocalProofs(round.Suite.Hash, round.StampRoot, round.StampLeaves, round.StampProofs) == true {
dbg.Lvl4("Local Proofs of", round.Name, "successful for round "+
strconv.Itoa(round.RoundNbr))
} else {
panic("Local Proofs" + round.Name + " unsuccessful for round " +
strconv.Itoa(round.RoundNbr))
}
}
}
out.Com.MTRoot = round.StampRoot
round.RoundCosi.Commitment(in, out)
return nil
}
func calculate_root(transactions TransactionList) (res string) {
var hashes []hashid.HashId
for _, t := range transactions.Txs {
temp, _ := hex.DecodeString(t.Hash)
hashes = append(hashes, temp)
}
out, _ := proof.ProofTree(sha256.New, hashes)
res = hex.EncodeToString(out)
return
}
func (s *Server) AggregateCommits(view int) []byte {
//dbg.Lvl4(s.Name(), "calling AggregateCommits")
s.mux.Lock()
// get data from s once to avoid refetching from structure
Queue := s.Queue
READING := s.READING
PROCESSING := s.PROCESSING
// messages read will now be processed
READING, PROCESSING = PROCESSING, READING
s.READING, s.PROCESSING = s.PROCESSING, s.READING
s.Queue[READING] = s.Queue[READING][:0]
// give up if nothing to process
if len(Queue[PROCESSING]) == 0 {
s.mux.Unlock()
s.Root = make([]byte, hashid.Size)
s.Proofs = make([]proof.Proof, 1)
return s.Root
}
// pull out to be Merkle Tree leaves
s.Leaves = make([]hashid.HashId, 0)
for _, msg := range Queue[PROCESSING] {
s.Leaves = append(s.Leaves, hashid.HashId(msg.Tsm.Sreq.Val))
}
s.mux.Unlock()
// non root servers keep track of rounds here
if !s.IsRoot(view) {
s.rLock.Lock()
lsr := s.LastRound()
mr := s.maxRounds
s.rLock.Unlock()
// if this is our last round then close the connections
if lsr >= mr && mr >= 0 {
s.closeChan <- true
}
}
// create Merkle tree for this round's messages and check corectness
s.Root, s.Proofs = proof.ProofTree(s.Suite().Hash, s.Leaves)
if sign.DEBUG == true {
if proof.CheckLocalProofs(s.Suite().Hash, s.Root, s.Leaves, s.Proofs) == true {
dbg.Lvl4("Local Proofs of", s.Name(), "successful for round "+strconv.Itoa(int(s.LastRound())))
} else {
panic("Local Proofs" + s.Name() + " unsuccessful for round " + strconv.Itoa(int(s.LastRound())))
}
}
return s.Root
}
func (cosi *CosiStruct) ComputeCombinedMerkleRoot() {
// add hash of whole log to leaves
cosi.Leaves = append(cosi.Leaves, cosi.HashedLog)
// compute MT root based on Log as right child and
// MT of leaves as left child and send it up to parent
sort.Sort(hashid.ByHashId(cosi.Leaves))
left, proofs := proof.ProofTree(cosi.Suite.Hash, cosi.Leaves)
right := cosi.HashedLog
moreLeaves := make([]hashid.HashId, 0)
moreLeaves = append(moreLeaves, left, right)
cosi.MTRoot, _ = proof.ProofTree(cosi.Suite.Hash, moreLeaves)
// Hashed Log has to come first in the proof; len(sn.CMTRoots)+1 proofs
cosi.Proofs = make(map[string]proof.Proof, 0)
for name := range cosi.Children {
cosi.Proofs[name] = append(cosi.Proofs[name], right)
}
cosi.Proofs["local"] = append(cosi.Proofs["local"], right)
// separate proofs by children (need to send personalized proofs to children)
// also separate local proof (need to send it to timestamp server)
cosi.SeparateProofs(proofs, cosi.Leaves)
}