func ComputeCryptoHash(content ...[]byte) []byte { combinedContent := []byte{} for _, b := range content { combinedContent = append(combinedContent, b...) } return util.ComputeCryptoHash(combinedContent) }
func (inst *instance) execute(payload []byte) { tx := &pb.Transaction{ Payload: payload, } txs := []*pb.Transaction{tx} txBatchID := base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(payload)) if err := inst.BeginTxBatch(txBatchID); err != nil { fmt.Printf("Failed to begin transaction %s: %v", txBatchID, err) return } if _, err := inst.ExecTxs(txBatchID, txs); nil != err { fmt.Printf("Fail to execute transaction %s: %v", txBatchID, err) if err := inst.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } if _, err := inst.CommitTxBatch(txBatchID, nil); err != nil { fmt.Printf("Failed to commit transaction %s to the ledger: %v", txBatchID, err) if err = inst.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } }
func (trieNode *trieNode) computeCryptoHash() []byte { stateTrieLogger.Debug("Enter computeCryptoHash() for trieNode [%s]", trieNode) var cryptoHashContent []byte if trieNode.containsValue() { stateTrieLogger.Debug("Adding value to hash computation for trieNode [%s]", trieNode) cryptoHashContent = append(cryptoHashContent, trieNode.trieKey.getEncodedBytes()...) cryptoHashContent = append(cryptoHashContent, trieNode.value...) } sortedChildrenIndexes := trieNode.getSortedChildrenIndex() for _, index := range sortedChildrenIndexes { childCryptoHash := trieNode.childrenCryptoHashes[index] stateTrieLogger.Debug("Adding hash [%#v] for child number [%d] to hash computation for trieNode [%s]", childCryptoHash, index, trieNode) cryptoHashContent = append(cryptoHashContent, childCryptoHash...) } if cryptoHashContent == nil { // node has no associated value and no associated children. stateTrieLogger.Debug("Returning nil as hash for trieNode = [%s]. Also, marking this key for deletion.", trieNode) trieNode.markedForDeletion = true return nil } if !trieNode.containsValue() && trieNode.getNumChildren() == 1 { // node has no associated value and has a single child. Propagate the child hash up stateTrieLogger.Debug("Returning hash as of a single child for trieKey = [%s]", trieNode.trieKey) return cryptoHashContent } stateTrieLogger.Debug("Recomputing hash for trieKey = [%s]", trieNode) return util.ComputeCryptoHash(cryptoHashContent) }
//hashFilesInDir computes h=hash(h,file bytes) for each file in a directory //Directory entries are traversed recursively. In the end a single //hash value is returned for the entire directory structure func hashFilesInDir(rootDir string, dir string, hash []byte, tw *tar.Writer) ([]byte, error) { //ReadDir returns sorted list of files in dir fis, err := ioutil.ReadDir(rootDir + "/" + dir) if err != nil { return hash, fmt.Errorf("ReadDir failed %s\n", err) } for _, fi := range fis { name := fmt.Sprintf("%s/%s", dir, fi.Name()) if fi.IsDir() { var err error hash, err = hashFilesInDir(rootDir, name, hash, tw) if err != nil { return hash, err } continue } buf, err := ioutil.ReadFile(rootDir + "/" + name) if err != nil { fmt.Printf("Error reading %s\n", err) return hash, err } newSlice := make([]byte, len(hash)+len(buf)) copy(newSlice[len(buf):], hash[:]) //hash = md5.Sum(newSlice) hash = util.ComputeCryptoHash(newSlice) if tw != nil { if err = addFile(tw, "src/"+name, fi, buf); err != nil { return hash, fmt.Errorf("Error adding file to tar %s", err) } } } return hash, nil }
func (op *obcSieve) processExecute() { if op.currentReq != "" { return } primary := op.pbft.primary(op.epoch) exec := op.queuedExec[primary] delete(op.queuedExec, primary) if exec == nil { return } if !(exec.View == op.epoch && op.pbft.primary(op.epoch) == exec.ReplicaId && op.pbft.activeView) { logger.Debug("Invalid execute from %d", exec.ReplicaId) return } if exec.BlockNumber != op.blockNumber+1 { logger.Debug("Invalid block number in execute: expected %d, got %d", op.blockNumber+1, exec.BlockNumber) return } logger.Debug("Sieve replica %d received exec from %d, epoch=%d, blockNo=%d", op.id, exec.ReplicaId, exec.View, exec.BlockNumber) op.currentReq = base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(exec.Request)) op.blockNumber++ op.begin() tx := &pb.Transaction{} proto.Unmarshal(exec.Request, tx) op.currentTx = []*pb.Transaction{tx} hashes, _ := op.cpi.ExecTXs(op.currentTx) // for simplicity's sake, we use the pbft timer op.pbft.startTimer(op.pbft.requestTimeout) op.currentResult = hashes verify := &Verify{ View: exec.View, BlockNumber: exec.BlockNumber, RequestDigest: op.currentReq, ResultDigest: op.currentResult, ReplicaId: op.id, } op.pbft.sign(verify) logger.Debug("Sieve replica %d sending verify blockNo=%d", op.id, verify.BlockNumber) op.broadcastMsg(&SieveMessage{&SieveMessage_Verify{verify}}) op.recvVerify(verify) }
func (c *bucketHashCalculator) computeCryptoHash() []byte { if c.currentChaincodeID != "" { c.appendCurrentChaincodeData() c.currentChaincodeID = "" c.dataNodes = nil } logger.Debug("Hashable content for bucket [%s]: length=%d, contentInStringForm=[%s]", c.bucketKey, len(c.hashingData), string(c.hashingData)) if util.IsNil(c.hashingData) { return nil } return openchainUtil.ComputeCryptoHash(c.hashingData) }
func expectedCryptoHashForTest(key *trieKey, value []byte, childrenHashes ...[]byte) []byte { expectedHash := []byte{} if key != nil { keyBytes := key.getEncodedBytes() expectedHash = append(expectedHash, proto.EncodeVarint(uint64(len(keyBytes)))...) expectedHash = append(expectedHash, keyBytes...) expectedHash = append(expectedHash, value...) } for _, b := range childrenHashes { expectedHash = append(expectedHash, b...) } return util.ComputeCryptoHash(expectedHash) }
func (op *obcSieve) processExecute() { if op.currentReq != "" { return } primary := op.pbft.primary(op.epoch) exec := op.queuedExec[primary] delete(op.queuedExec, primary) if exec == nil { return } if !(exec.View == op.epoch && op.pbft.primary(op.epoch) == exec.ReplicaId && op.pbft.activeView) { logger.Debug("Invalid execute from %d", exec.ReplicaId) return } if exec.BlockNumber != op.blockNumber+1 { logger.Debug("Block block number in execute wrong: expected %d, got %d", op.blockNumber, exec.BlockNumber) return } op.currentReq = base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(exec.Request)) logger.Debug("Sieve replica %d received exec from %d, epoch=%d, blockNo=%d from request=%s", op.id, exec.ReplicaId, exec.View, exec.BlockNumber, op.currentReq) // With the execution decoupled from the ordering, this sanity check is challenging and introduces a race /* blockchainSize, _ := op.stack.GetBlockchainSize() blockchainSize-- if op.blockNumber != blockchainSize { logger.Critical("Sieve replica %d block number and ledger blockchain size diverged: blockNo=%d, blockchainSize=%d", op.id, op.blockNumber, blockchainSize) return } */ op.currentView = exec.View op.blockNumber = exec.BlockNumber tx := &pb.Transaction{} proto.Unmarshal(exec.Request, tx) op.executor.Execute(exec.BlockNumber, []*pb.Transaction{tx}, &ExecutionInfo{ Validate: true, }) }
//name could be ChaincodeID.Name or ChaincodeID.Path func generateHashFromSignature(path string, ctor string, args []string) []byte { fargs := ctor if args != nil { for _, str := range args { fargs = fargs + str } } cbytes := []byte(path + fargs) b := make([]byte, len(cbytes)) copy(b, cbytes) hash := util.ComputeCryptoHash(b) return hash }
func (instance *pbftCore) sign(s signable) error { s.setSignature(nil) // TODO once the crypto package is integrated // cryptoID, _, _ := instance.cpi.GetReplicaID() // s.setID(cryptoID) id := []byte("XXX ID") s.setID(id) raw, err := s.serialize() if err != nil { return err } // s.setSignature(instance.cpi.Sign(raw)) s.setSignature(util.ComputeCryptoHash(append(id, raw...))) return nil }
func BenchmarkCryptoHash(b *testing.B) { flags := flag.NewFlagSet("testParams", flag.ExitOnError) numBytesPointer := flags.Int("NumBytes", -1, "Number of Bytes") flags.Parse(testParams) numBytes := *numBytesPointer if numBytes == -1 { b.Fatal("Missing value for parameter NumBytes") } randomBytes := testutil.ConstructRandomBytes(b, numBytes) //b.Logf("byte size=%d, b.N=%d", len(randomBytes), b.N) b.ResetTimer() for i := 0; i < b.N; i++ { util.ComputeCryptoHash(randomBytes) } }
func (instance *pbftCore) verify(s signable) error { origSig := s.getSignature() s.setSignature(nil) raw, err := s.serialize() s.setSignature(origSig) if err != nil { return err } id := s.getID() // XXX check that s.Id() is a valid replica // instance.cpi.Verify(s.Id(), origSig, raw) if !reflect.DeepEqual(util.ComputeCryptoHash(append(id, raw...)), origSig) { return fmt.Errorf("invalid signature") } return nil }
// execute an opaque request which corresponds to an OBC Transaction func (op *obcBatch) execute(tbRaw []byte) { tb := &pb.TransactionBlock{} err := proto.Unmarshal(tbRaw, tb) if err != nil { return } txs := tb.Transactions txBatchID := base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(tbRaw)) for i, tx := range txs { txRaw, _ := proto.Marshal(tx) if err = op.validate(txRaw); err != nil { err = fmt.Errorf("Request in transaction %d from batch %s did not verify: %s", i, txBatchID, err) logger.Error(err.Error()) return } } if err := op.stack.BeginTxBatch(txBatchID); err != nil { err = fmt.Errorf("Failed to begin transaction batch %s: %v", txBatchID, err) logger.Error(err.Error()) return } if _, err := op.stack.ExecTxs(txBatchID, txs); nil != err { err = fmt.Errorf("Fail to execute transaction batch %s: %v", txBatchID, err) logger.Error(err.Error()) if err = op.stack.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction batch %s: %v", txBatchID, err)) } return } if _, err = op.stack.CommitTxBatch(txBatchID, nil); err != nil { err = fmt.Errorf("Failed to commit transaction batch %s to the ledger: %v", txBatchID, err) logger.Error(err.Error()) if err = op.stack.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction batch %s: %v", txBatchID, err)) } return } }
// execute an opaque request which corresponds to an OBC Transaction func (op *obcClassic) execute(txRaw []byte) { if err := op.validate(txRaw); err != nil { err = fmt.Errorf("Request in transaction did not validate: %s", err) logger.Error(err.Error()) return } tx := &pb.Transaction{} err := proto.Unmarshal(txRaw, tx) if err != nil { err = fmt.Errorf("Unable to unmarshal transaction: %v", err) logger.Error(err.Error()) return } txs := []*pb.Transaction{tx} txBatchID := base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(txRaw)) if err := op.stack.BeginTxBatch(txBatchID); err != nil { err = fmt.Errorf("Failed to begin transaction %s: %v", txBatchID, err) logger.Error(err.Error()) return } if _, err := op.stack.ExecTxs(txBatchID, txs); nil != err { err = fmt.Errorf("Failed to execute transaction %s: %v", txBatchID, err) logger.Error(err.Error()) if err = op.stack.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } if _, err = op.stack.CommitTxBatch(txBatchID, nil); err != nil { err = fmt.Errorf("Failed to commit transaction %s to the ledger: %v", txBatchID, err) logger.Error(err.Error()) if err = op.stack.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } }
func computeDataNodesCryptoHash(bucketKey *bucketKey, updatedNodes dataNodes, existingNodes dataNodes) []byte { logger.Debug("Computing crypto-hash for bucket [%s]. numUpdatedNodes=[%d], numExistingNodes=[%d]", bucketKey, len(updatedNodes), len(existingNodes)) hashableContent := []byte{} i := 0 j := 0 for i < len(updatedNodes) && j < len(existingNodes) { updatedNode := updatedNodes[i] existingNode := existingNodes[j] c := bytes.Compare(updatedNode.dataKey.compositeKey, existingNode.dataKey.compositeKey) var nextNode *dataNode switch c { case -1: nextNode = updatedNode i++ case 0: nextNode = updatedNode i++ j++ case 1: nextNode = existingNode j++ } hashableContent = addNodeData(hashableContent, nextNode) } var remainingNodes dataNodes if i < len(updatedNodes) { remainingNodes = updatedNodes[i:] } else if j < len(existingNodes) { remainingNodes = existingNodes[j:] } for _, remainingNode := range remainingNodes { hashableContent = addNodeData(hashableContent, remainingNode) } logger.Debug("Hashable content for bucket [%s] = [%s]", bucketKey, string(hashableContent)) if util.IsNil(hashableContent) { return nil } return openchainUtil.ComputeCryptoHash(hashableContent) }
// GetHash returns the hash of this block. func (block *Block) GetHash() ([]byte, error) { // copy the block and remove the non-hash data blockBytes, err := block.Bytes() if err != nil { return nil, fmt.Errorf("Could not calculate hash of block: %s", err) } blockCopy, err := UnmarshallBlock(blockBytes) if err != nil { return nil, fmt.Errorf("Could not calculate hash of block: %s", err) } blockCopy.NonHashData = nil // Hash the block data, err := proto.Marshal(blockCopy) if err != nil { return nil, fmt.Errorf("Could not calculate hash of block: %s", err) } hash := util.ComputeCryptoHash(data) return hash, nil }
// ComputeCryptoHash computes crypto-hash for the data held // returns nil if no data is present func (stateDelta *StateDelta) ComputeCryptoHash() []byte { if stateDelta.IsEmpty() { return nil } var buffer bytes.Buffer sortedChaincodeIds := stateDelta.GetUpdatedChaincodeIds(true) for _, chaincodeID := range sortedChaincodeIds { buffer.WriteString(chaincodeID) chaincodeStateDelta := stateDelta.chaincodeStateDeltas[chaincodeID] sortedKeys := chaincodeStateDelta.getSortedKeys() for _, key := range sortedKeys { buffer.WriteString(key) updatedValue := chaincodeStateDelta.get(key) if !updatedValue.IsDelete() { buffer.Write(updatedValue.value) } } } hashingContent := buffer.Bytes() logger.Debug("computing hash on %#v", hashingContent) return util.ComputeCryptoHash(hashingContent) }
func (bucketNode *bucketNode) computeCryptoHash() []byte { cryptoHashContent := []byte{} numChildren := 0 for i, childCryptoHash := range bucketNode.childrenCryptoHash { if util.NotNil(childCryptoHash) { numChildren++ logger.Debug("Appending crypto-hash for child bucket = [%s]", bucketNode.bucketKey.getChildKey(i)) cryptoHashContent = append(cryptoHashContent, childCryptoHash...) } } if numChildren == 0 { logger.Debug("Returning <nil> crypto-hash of bucket = [%s] - because, it has not children", bucketNode.bucketKey) bucketNode.markedForDeletion = true return nil } if numChildren == 1 { logger.Debug("Propagating crypto-hash of single child node for bucket = [%s]", bucketNode.bucketKey) return cryptoHashContent } logger.Debug("Computing crypto-hash for bucket [%s] by merging [%d] children", bucketNode.bucketKey, numChildren) return openchainUtil.ComputeCryptoHash(cryptoHashContent) }
// execute an opaque request which corresponds to an OBC Transaction func (op *obcClassic) execute(txRaw []byte) { if err := op.verify(txRaw); err != nil { logger.Error("Request in transaction did not verify: %s", err) return } tx := &pb.Transaction{} err := proto.Unmarshal(txRaw, tx) if err != nil { logger.Error("Unable to unmarshal transaction: %v", err) return } txs := []*pb.Transaction{tx} txBatchID := base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(txRaw)) if err := op.cpi.BeginTxBatch(txBatchID); err != nil { logger.Error("Failed to begin transaction %s: %v", txBatchID, err) return } _, errs := op.cpi.ExecTXs(txs) if errs[len(txs)] != nil { logger.Error("Fail to execute transaction %s: %v", txBatchID, errs) if err = op.cpi.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } if err = op.cpi.CommitTxBatch(txBatchID, txs, nil); err != nil { logger.Error("Failed to commit transaction %s to the ledger: %v", txBatchID, err) if err = op.cpi.RollbackTxBatch(txBatchID); err != nil { panic(fmt.Errorf("Unable to rollback transaction %s: %v", txBatchID, err)) } return } }
func ComputeCryptoHash(content ...[]byte) []byte { return util.ComputeCryptoHash(AppendAll(content...)) }
func hashReq(req *Request) (digest string) { reqRaw, _ := proto.Marshal(req) return base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(reqRaw)) }
func (op *obcSieve) processExecute() { if op.pbft.sts.InProgress() { return } if op.currentReq != "" { return } primary := op.pbft.primary(op.epoch) exec := op.queuedExec[primary] delete(op.queuedExec, primary) if exec == nil { return } if !(exec.View == op.epoch && op.pbft.primary(op.epoch) == exec.ReplicaId && op.pbft.activeView) { logger.Debug("Invalid execute from %d", exec.ReplicaId) return } if exec.BlockNumber != op.blockNumber+1 { logger.Debug("Invalid block number in execute: expected %d, got %d", op.blockNumber+1, exec.BlockNumber) return } logger.Debug("Sieve replica %d received exec from %d, epoch=%d, blockNo=%d", op.id, exec.ReplicaId, exec.View, exec.BlockNumber) blockchainSize, _ := op.stack.GetBlockchainSize() blockchainSize-- if op.blockNumber != blockchainSize { logger.Critical("Sieve replica %d block number and ledger blockchain size diverged: blockNo=%d, blockchainSize=%d", op.id, op.blockNumber, blockchainSize) return } op.currentReq = base64.StdEncoding.EncodeToString(util.ComputeCryptoHash(exec.Request)) op.blockNumber++ op.begin() tx := &pb.Transaction{} proto.Unmarshal(exec.Request, tx) op.currentTx = []*pb.Transaction{tx} op.stack.ExecTxs(op.currentReq, op.currentTx) hash, err := op.previewCommit(op.blockNumber) if err != nil { err = fmt.Errorf("Sieve replica %d ignoring execute: %s", op.id, err) logger.Error(err.Error()) op.blockNumber-- op.currentReq = "" return } op.currentResult = hash logger.Debug("Sieve replica %d executed blockNo=%d, request=%s, result=%s", op.id, op.blockNumber, op.currentReq, op.currentResult) // for simplicity's sake, we use the pbft timer op.pbft.startTimer(op.pbft.requestTimeout) verify := &Verify{ View: exec.View, BlockNumber: exec.BlockNumber, RequestDigest: op.currentReq, ResultDigest: op.currentResult, ReplicaId: op.id, } op.pbft.sign(verify) logger.Debug("Sieve replica %d sending verify blockNo=%d", op.id, verify.BlockNumber) op.broadcastMsg(&SieveMessage{&SieveMessage_Verify{verify}}) op.recvVerify(verify) }