From 9d597754d2921f6b9d841cf9684041a1e2862929 Mon Sep 17 00:00:00 2001 From: ak Date: Tue, 4 Sep 2018 14:37:57 -0700 Subject: [PATCH 1/5] WIP commit --- identitychain/identitychain.go | 17 +++- identitychain/identitychain_handler.go | 64 ++++++++++-- identitymanage/identitymanage.go | 43 -------- node/node.go | 94 +++++++++++++++++- node/node_handler.go | 16 ++- pow/LICENSE | 21 ++++ pow/README.md | 57 +++++++++++ pow/api.go | 131 +++++++++++++++++++++++++ pow/api_test.go | 56 +++++++++++ pow/example_test.go | 25 +++++ pow/pow.go | 81 --------------- pow/sha2bday.go | 78 +++++++++++++++ proto/identity/identity.go | 4 +- runwait/run_wait.go | 27 +++-- 14 files changed, 562 insertions(+), 152 deletions(-) delete mode 100644 identitymanage/identitymanage.go create mode 100755 pow/LICENSE create mode 100755 pow/README.md create mode 100755 pow/api.go create mode 100755 pow/api_test.go create mode 100755 pow/example_test.go delete mode 100644 pow/pow.go create mode 100755 pow/sha2bday.go diff --git a/identitychain/identitychain.go b/identitychain/identitychain.go index ffd9e1372..0af4ba361 100644 --- a/identitychain/identitychain.go +++ b/identitychain/identitychain.go @@ -30,6 +30,7 @@ type IdentityChain struct { CurrentEpochStartTime int64 NumberOfShards int NumberOfNodesInShard int + PowMap map[p2p.Peer]uint32 } func seekRandomNumber(EpochNum int, SelectedIdentitites []*waitnode.WaitNode) int { @@ -50,17 +51,25 @@ type GlobalBlockchainConfig struct { //Shard func (IDC *IdentityChain) Shard() { - num := seekRandomNumber(IDC.EpochNum, IDC.SelectedIdentitites) - IDC.CreateShardAssignment(num) + IDC.CreateShardAssignment() IDC.ElectLeaders() + IDC.BroadCastNewConfiguration() } // func (IDC *IdentityChain) ElectLeaders() { } +func (IDC *IdentityChain) BroadCastNewConfiguration() { + // allPeers := make([]p2p.Peer, len(IDC.SelectedIdentitites)) + // msgToSend := proto. + // p2p.BroadCastMessage(allPeers, msgToSend) + +} + //CreateShardAssignment -func (IDC *IdentityChain) CreateShardAssignment(num int) { +func (IDC *IdentityChain) CreateShardAssignment() { + num := seekRandomNumber(IDC.EpochNum, IDC.SelectedIdentitites) IDC.NumberOfShards = IDC.NumberOfShards + needNewShards() IDC.SelectedIdentitites = generateRandomPermutations(num, IDC.SelectedIdentitites) IDC.PeerToShardMap = make(map[*waitnode.WaitNode]int) @@ -81,7 +90,7 @@ func generateRandomPermutations(num int, SelectedIdentitites []*waitnode.WaitNod return SelectedIdentititesCopy } -// SelectIds +// SelectIds as func (IDC *IdentityChain) SelectIds() { selectNumber := IDC.NumberOfNodesInShard - len(IDC.Identities) IB := IDC.GetLatestBlock() diff --git a/identitychain/identitychain_handler.go b/identitychain/identitychain_handler.go index 4ac1b6c3f..eb9d46326 100644 --- a/identitychain/identitychain_handler.go +++ b/identitychain/identitychain_handler.go @@ -1,14 +1,17 @@ package identitychain import ( + "bytes" + "encoding/binary" "fmt" + "math/rand" "net" "os" + "github.com/simple-rules/harmony-benchmark/node" "github.com/simple-rules/harmony-benchmark/p2p" "github.com/simple-rules/harmony-benchmark/proto" proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity" - "github.com/simple-rules/harmony-benchmark/waitnode" ) //IdentityChainHandler handles registration of new Identities @@ -40,23 +43,70 @@ func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) { } switch msgCategory { case proto.IDENTITY: - actionType := proto_identity.IdentityMessageType(msgType) + actionType := proto_identity.MessageType(msgType) switch actionType { - case proto_identity.IDENTITY: + case proto_identity.REGISTER: IDC.registerIdentity(msgPayload) + case proto_identity.ANNOUNCE: + IDC.acceptNewConnection(msgPayload) } } } func (IDC *IdentityChain) registerIdentity(msgPayload []byte) { - identityPayload, err := proto_identity.GetIdentityMessagePayload(msgPayload) + payload, err := proto_identity.GetIdentityMessagePayload(msgPayload) if err != nil { IDC.log.Error("identity payload not read") } else { fmt.Println("identity payload read") } - NewWaitNode := waitnode.DeserializeWaitNode(identityPayload) - IDC.PendingIdentities = append(IDC.PendingIdentities, NewWaitNode) - fmt.Println(len(IDC.PendingIdentities)) + //reconstruct the challenge and check whether its correct + offset := 0 + //proof := payload[offset : offset+64] + + offset = offset + 64 + Node := node.DeserializeNode(payload[offset:]) + fmt.Println(Node.Self) + os.Exit(1) + // id := []byte(IDC.PowMap[Node.Self]) + // req := pow.NewRequest(5, id) + // ok, _ := pow.Check(req, string(proof), []byte("This is blockchash data")) + // if ok { + // IDC.PendingIdentities = append(IDC.PendingIdentities, Node) + // fmt.Println(len(IDC.PendingIdentities)) //Fix why IDC does not have log working. + // } else { + // fmt.Println("identity proof of work not accepted") + // } +} + +func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) { + + identityPayload, err := proto_identity.GetIdentityMessagePayload(msgPayload) + if err != nil { + fmt.Println("There was a error in reading the identity payload") + } + Node := node.DeserializeNode(identityPayload) + buffer := bytes.NewBuffer([]byte{}) + challengeNonce := uint32(rand.Intn(1000)) + IDC.PowMap[Node.Self] = challengeNonce + + // 64 byte length of challenge + fourBytes := make([]byte, 64) + binary.BigEndian.PutUint32(fourBytes, challengeNonce) + buffer.Write(fourBytes) + + sendMsgPayload := buffer.Bytes() + + // 32 byte block hash + // buffer.Write(prevBlockHash) + // The message is missing previous BlockHash, this is because we don't actively maintain a identitychain + // This canbe included in the fulfill request. + + // Message should be encrypted and then signed to follow PKE. + //IDC should accept node publickey, encrypt the nonce and blockhash + // Then sign the message by own private key and send the message back. + + msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.REGISTER, sendMsgPayload) + p2p.SendMessage(Node.Self, msgToSend) } diff --git a/identitymanage/identitymanage.go b/identitymanage/identitymanage.go deleted file mode 100644 index aaef5dfa3..000000000 --- a/identitymanage/identitymanage.go +++ /dev/null @@ -1,43 +0,0 @@ -package identitymanage - -// import ( -// "bytes" -// "encoding/binary" -// "log" - -// "github.com/dedis/kyber" -// ) - -// // Consensus data containing all info related to one round of consensus process -// type Identity struct { -// priKey kyber.Scalar -// pubKey kyber.Point -// Log log.Logger -// } - -// // Construct the response message to send to leader (assumption the consensus data is already verified) -// func (identity *Identity) registerIdentity(msgType proto_consensus.MessageType, response kyber.Scalar) []byte { -// buffer := bytes.NewBuffer([]byte{}) - -// // 4 byte consensus id -// fourBytes := make([]byte, 4) -// binary.BigEndian.PutUint32(fourBytes, consensus.consensusId) -// buffer.Write(fourBytes) - -// // 32 byte block hash -// buffer.Write(consensus.blockHash[:32]) - -// // 2 byte validator id -// twoBytes := make([]byte, 2) -// binary.BigEndian.PutUint16(twoBytes, consensus.nodeId) -// buffer.Write(twoBytes) - -// // 32 byte of response -// response.MarshalTo(buffer) - -// // 64 byte of signature on previous data -// signature := consensus.signMessage(buffer.Bytes()) -// buffer.Write(signature) - -// return proto_identity.ConstructIdentityMessage(msgType, buffer.Bytes()) -// } diff --git a/node/node.go b/node/node.go index 895e76413..ef0d9819e 100644 --- a/node/node.go +++ b/node/node.go @@ -1,11 +1,16 @@ package node import ( - "github.com/simple-rules/harmony-benchmark/crypto/pki" + "bytes" + "encoding/gob" "net" "os" "sync" + "github.com/simple-rules/harmony-benchmark/crypto/pki" + "github.com/simple-rules/harmony-benchmark/pow" + "github.com/simple-rules/harmony-benchmark/proto/identity" + "github.com/simple-rules/harmony-benchmark/blockchain" "github.com/simple-rules/harmony-benchmark/client" "github.com/simple-rules/harmony-benchmark/consensus" @@ -31,6 +36,9 @@ type Node struct { crossTxToReturnMutex sync.Mutex ClientPeer *p2p.Peer // The peer for the benchmark tx generator client, used for leaders to return proof-of-accept Client *client.Client // The presence of a client object means this node will also act as a client + IsWaiting bool + Self p2p.Peer + IDCPeer p2p.Peer } // Add new crossTx and proofs to the list of crossTx that needs to be sent back to client @@ -96,6 +104,90 @@ func (node *Node) countNumTransactionsInBlockchain() int { return count } +//ConnectIdentityChain connects to identity chain +func (node *Node) ConnectIdentityChain() { + IDCPeer := node.IDCPeer + p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.ANNOUNCE, node.SerializeNode())) +} + +//NewWaitNode is a way to initiate a waiting no +func NewWaitNode(peer, IDCPeer p2p.Peer) Node { + node := Node{} + node.Self = peer + node.IDCPeer = IDCPeer + return node +} + +//NewNodefromIDC +func NewNodefromIDC(node Node, consensus *consensus.Consensus, db *db.LDBDatabase) *Node { + + if consensus != nil { + // Consensus and associated channel to communicate blocks + node.Consensus = consensus + node.BlockChannel = make(chan blockchain.Block) + + // Genesis Block + // TODO(minh): Use or implement new function in blockchain package for this. + genesisBlock := &blockchain.Blockchain{} + genesisBlock.Blocks = make([]*blockchain.Block, 0) + // TODO(RJ): use miner's address as coinbase address + coinbaseTx := blockchain.NewCoinbaseTX(pki.GetAddressFromInt(1), "0", node.Consensus.ShardID) + genesisBlock.Blocks = append(genesisBlock.Blocks, blockchain.NewGenesisBlock(coinbaseTx, node.Consensus.ShardID)) + node.blockchain = genesisBlock + + // UTXO pool from Genesis block + node.UtxoPool = blockchain.CreateUTXOPoolFromGenesisBlockChain(node.blockchain) + + // Initialize level db. + node.db = db + + } + // Logger + node.log = log.New() + + return &node +} + +func (node *Node) processPOWMessage(payload []byte) { + IDCPeer := node.IDCPeer + offset := 0 + // 4 byte challenge nonce id + req := pow.NewRequest(5, payload[offset:offset+64]) + proof, _ := pow.Fulfil(req, []byte("This is blockchash data")) //"some bound dat" + + proofBytes := make([]byte, 64) + copy(proofBytes[:], proof) + buffer := bytes.NewBuffer([]byte{}) + buffer.Write(proofBytes) + + buffer.Write(node.SerializeNode()) + + msgPayload := buffer.Bytes() + p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.REGISTER, msgPayload)) +} + +//SerializeWaitNode serializes the node +func (node *Node) SerializeNode() []byte { + var result bytes.Buffer + encoder := gob.NewEncoder(&result) + err := encoder.Encode(node) + if err != nil { + node.log.Error("Could not serialize node") + } + return result.Bytes() +} + +// DeserializeWaitNode deserializes the node +func DeserializeNode(d []byte) *Node { + var wn Node + decoder := gob.NewDecoder(bytes.NewReader(d)) + err := decoder.Decode(&wn) + if err != nil { + log.Error("Could not de-serialize node") + } + return &wn +} + // Create a new Node func New(consensus *consensus.Consensus, db *db.LDBDatabase) *Node { node := Node{} diff --git a/node/node_handler.go b/node/node_handler.go index 7d86ca873..f403bccf1 100644 --- a/node/node_handler.go +++ b/node/node_handler.go @@ -3,17 +3,19 @@ package node import ( "bytes" "encoding/gob" - "github.com/simple-rules/harmony-benchmark/log" "net" "os" "strconv" "time" + "github.com/simple-rules/harmony-benchmark/log" + "github.com/simple-rules/harmony-benchmark/blockchain" "github.com/simple-rules/harmony-benchmark/p2p" "github.com/simple-rules/harmony-benchmark/proto" "github.com/simple-rules/harmony-benchmark/proto/client" "github.com/simple-rules/harmony-benchmark/proto/consensus" + proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity" proto_node "github.com/simple-rules/harmony-benchmark/proto/node" ) @@ -54,6 +56,18 @@ func (node *Node) NodeHandler(conn net.Conn) { } switch msgCategory { + case proto.IDENTITY: + actionType := proto_identity.IdentityMessageType(msgType) + switch actionType { + case proto_identity.IDENTITY: + messageType := proto_identity.MessageType(msgPayload[0]) + switch messageType { + case proto_identity.REGISTER: + node.processPOWMessage(msgPayload) + case proto_identity.ANNOUNCE: + node.log.Error("Announce message should be sent to IdentityChain") + } + } case proto.CONSENSUS: actionType := consensus.ConsensusMessageType(msgType) switch actionType { diff --git a/pow/LICENSE b/pow/LICENSE new file mode 100755 index 000000000..bd93e247d --- /dev/null +++ b/pow/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Bas Westerbaan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/pow/README.md b/pow/README.md new file mode 100755 index 000000000..5f7c83c17 --- /dev/null +++ b/pow/README.md @@ -0,0 +1,57 @@ +go-pow +====== + +`go-pow` is a simple Go package to add (asymmetric) *Proof of Work* to your service. + +To create a Proof-of-Work request (with difficulty 5), use `pow.NewRequest`: + +```go +req := pow.NewRequest(5, someRandomNonce) +``` + +This returns a string like `sha2bday-5-c29tZSByYW5kb20gbm9uY2U`, +which can be passed on to the client. +The client fulfils the proof of work by running `pow.Fulfil`: + +```go +proof, _ := pow.Fulfil(req, []byte("some bound data")) +``` + +The client returns the proof (in this case `AAAAAAAAAAMAAAAAAAAADgAAAAAAAAAb`) +to the server, which can check it is indeed a valid proof of work, by running: + + +``` go +ok, _ := pow.Check(req, proof, []byte("some bound data")) +``` + +Notes +----- +1. There should be at least sufficient randomness in either the `nonce` passed to + `NewRequest` or the `data` passed to `Fulfil` and `Check`. + Thus it is fine to use the same bound `data` for every client, if every client + get a different `nonce` in its proof-of-work request. + It is also fine to use the same `nonce` in the proof-of-work request, + if every client is (by the encapsulating protocol) forced to use + different bound `data`. +2. The work to fulfil a request scales exponentially in the difficulty parameter. + The work to check it proof is correct remains constant: + + ``` + Check on Difficulty=5 500000 2544 ns/op + Check on Difficulty=10 500000 2561 ns/op + Check on Difficulty=15 500000 2549 ns/op + Check on Difficulty=20 500000 2525 ns/op + Fulfil on Difficulty=5 100000 15725 ns/op + Fulfil on Difficulty=10 30000 46808 ns/op + Fulfil on Difficulty=15 2000 955606 ns/op + Fulfil on Difficulty=20 200 6887722 ns/op + ``` + +To do +----- + + - Support for [equihash](https://www.cryptolux.org/index.php/Equihash) would be nice. + - Port to Python, Java, Javascript, ... + - Parallelize. + diff --git a/pow/api.go b/pow/api.go new file mode 100755 index 000000000..f4e5ba906 --- /dev/null +++ b/pow/api.go @@ -0,0 +1,131 @@ +// Create and fulfill proof of work requests. +package pow + +import ( + "encoding/base64" + "fmt" + "strconv" + "strings" +) + +type Algorithm string + +const ( + Sha2BDay Algorithm = "sha2bday" +) + +// Represents a proof-of-work request. +type Request struct { + + // The requested algorithm + Alg Algorithm + + // The requested difficulty + Difficulty uint32 + + // Nonce to diversify the request + Nonce []byte +} + +// Represents a completed proof-of-work +type Proof struct { + buf []byte +} + +// Convenience function to create a new sha3bday proof-of-work request +// as a string +func NewRequest(difficulty uint32, nonce []byte) string { + req := Request{ + Difficulty: difficulty, + Nonce: nonce, + Alg: Sha2BDay, + } + s, _ := req.MarshalText() + return string(s) +} + +func (proof Proof) MarshalText() ([]byte, error) { + return []byte(base64.RawStdEncoding.EncodeToString(proof.buf)), nil +} + +func (proof *Proof) UnmarshalText(buf []byte) error { + var err error + proof.buf, err = base64.RawStdEncoding.DecodeString(string(buf)) + return err +} + +func (req Request) MarshalText() ([]byte, error) { + return []byte(fmt.Sprintf("%s-%d-%s", + req.Alg, + req.Difficulty, + string(base64.RawStdEncoding.EncodeToString(req.Nonce)))), nil +} + +func (req *Request) UnmarshalText(buf []byte) error { + bits := strings.SplitN(string(buf), "-", 3) + if len(bits) != 3 { + return fmt.Errorf("There should be two dashes in a PoW request") + } + alg := Algorithm(bits[0]) + if alg != Sha2BDay { + return fmt.Errorf("%s: unsupported algorithm", bits[0]) + } + req.Alg = alg + diff, err := strconv.Atoi(bits[1]) + if err != nil { + return err + } + req.Difficulty = uint32(diff) + req.Nonce, err = base64.RawStdEncoding.DecodeString(bits[2]) + if err != nil { + return err + } + return nil +} + +// Convenience function to check whether a proof of work is fulfilled +func Check(request, proof string, data []byte) (bool, error) { + var req Request + var prf Proof + err := req.UnmarshalText([]byte(request)) + if err != nil { + return false, err + } + err = prf.UnmarshalText([]byte(proof)) + if err != nil { + return false, err + } + return prf.Check(req, data), nil +} + +// Fulfil the proof-of-work request. +func (req *Request) Fulfil(data []byte) Proof { + switch req.Alg { + case Sha2BDay: + return Proof{fulfilSha2BDay(req.Nonce, req.Difficulty, data)} + default: + panic("No such algorithm") + } +} + +// Convenience function to fulfil the proof of work request +func Fulfil(request string, data []byte) (string, error) { + var req Request + err := req.UnmarshalText([]byte(request)) + if err != nil { + return "", err + } + proof := req.Fulfil(data) + s, _ := proof.MarshalText() + return string(s), nil +} + +// Check whether the proof is ok +func (proof *Proof) Check(req Request, data []byte) bool { + switch req.Alg { + case Sha2BDay: + return checkSha2BDay(proof.buf, req.Nonce, data, req.Difficulty) + default: + panic("No such algorithm") + } +} diff --git a/pow/api_test.go b/pow/api_test.go new file mode 100755 index 000000000..2361288f7 --- /dev/null +++ b/pow/api_test.go @@ -0,0 +1,56 @@ +package pow + +import ( + "testing" +) + +func TestSha2BDay(t *testing.T) { + nonce := []byte{1, 2, 3, 4, 5} + data := []byte{2, 2, 3, 4, 5} + r := NewRequest(5, nonce) + proof, err := Fulfil(r, data) + if err != nil { + t.Fatalf("Fulfil: %v", err) + } + ok, err := Check(r, proof, data) + if err != nil { + t.Fatalf("Check: %v", err) + } + if !ok { + t.Fatalf("Proof of work should be ok") + } + ok, err = Check(r, proof, nonce) + if err != nil { + t.Fatalf("Check: %v", err) + } + if ok { + t.Fatalf("Proof of work should not be ok") + } +} + +func BenchmarkCheck5(b *testing.B) { benchmarkCheck(5, b) } +func BenchmarkCheck10(b *testing.B) { benchmarkCheck(10, b) } +func BenchmarkCheck15(b *testing.B) { benchmarkCheck(15, b) } +func BenchmarkCheck20(b *testing.B) { benchmarkCheck(20, b) } + +func benchmarkCheck(diff uint32, b *testing.B) { + req := NewRequest(diff, []byte{1, 2, 3, 4, 5}) + prf, _ := Fulfil(req, []byte{6, 7, 8, 9}) + b.ResetTimer() + for n := 0; n < b.N; n++ { + Check(req, prf, []byte{6, 7, 8, 9}) + } +} + +func BenchmarkFulfil5(b *testing.B) { benchmarkFulfil(5, b) } +func BenchmarkFulfil10(b *testing.B) { benchmarkFulfil(10, b) } +func BenchmarkFulfil15(b *testing.B) { benchmarkFulfil(15, b) } +func BenchmarkFulfil20(b *testing.B) { benchmarkFulfil(20, b) } + +func benchmarkFulfil(diff uint32, b *testing.B) { + req := NewRequest(diff, []byte{1, 2, 3, 4, 5}) + b.ResetTimer() + for n := 0; n < b.N; n++ { + Fulfil(req, []byte{6, 7, 8, 9}) + } +} diff --git a/pow/example_test.go b/pow/example_test.go new file mode 100755 index 000000000..cca46eb42 --- /dev/null +++ b/pow/example_test.go @@ -0,0 +1,25 @@ +package pow_test + +import ( + "fmt" // imported as pow + + "github.com/simple-rules/harmony-benchmark/pow" +) + +func Example() { + // Create a proof of work request with difficulty 5 + req := pow.NewRequest(5, []byte("some random nonce")) + fmt.Printf("req: %s\n", req) + + // Fulfil the proof of work + proof, _ := pow.Fulfil(req, []byte("some bound data")) + fmt.Printf("proof: %s\n", proof) + + // Check if the proof is correct + ok, _ := pow.Check(req, proof, []byte("some bound data")) + fmt.Printf("check: %v", ok) + + // Output: req: sha2bday-5-c29tZSByYW5kb20gbm9uY2U + // proof: AAAAAAAAAAMAAAAAAAAADgAAAAAAAAAb + // check: true +} diff --git a/pow/pow.go b/pow/pow.go deleted file mode 100644 index a8c31b3d5..000000000 --- a/pow/pow.go +++ /dev/null @@ -1,81 +0,0 @@ -package pow - -import ( - "bytes" - "crypto/sha256" - "encoding/binary" - "fmt" - "math" - "math/big" -) - -var ( - maxNonce = math.MaxUint32 -) - -const targetBits = 24 - -// ProofOfWork represents a proof-of-work -type ProofOfWork struct { - Challenge uint32 - target *big.Int - FinalNonce uint32 -} - -// NewProofOfWork builds and returns a ProofOfWork -func NewProofOfWork(c uint32) *ProofOfWork { - target := big.NewInt(1) - target.Lsh(target, uint(256-targetBits)) - - pow := &ProofOfWork{Challenge: c, target: target, FinalNonce: 0} - - return pow -} - -func (pow *ProofOfWork) prepareData(nonce uint32) []byte { - challenge := make([]byte, 4) - binary.LittleEndian.PutUint32(challenge, pow.Challenge) - nonceB := make([]byte, 4) - binary.LittleEndian.PutUint32(nonceB, nonce) - data := bytes.Join( - [][]byte{ - challenge, - nonceB, - }, - []byte{}, - ) - return data -} - -// Run performs a proof-of-work -func (pow *ProofOfWork) Run() int { - var hashInt big.Int - var hash [32]byte - nonce := 0 - for nonce < maxNonce { - data := pow.prepareData(uint32(nonce)) - - hash = sha256.Sum256(data) - fmt.Printf("\r%x", hash) - hashInt.SetBytes(hash[:]) - - if hashInt.Cmp(pow.target) == -1 { - pow.FinalNonce = uint32(nonce) - break - } else { - nonce++ - } - } - fmt.Print("\n\n") - return nonce -} - -// Validate validates block's PoW -func (pow *ProofOfWork) Validate(nonce uint32) bool { - var hashInt big.Int - data := pow.prepareData(nonce) - hash := sha256.Sum256(data) - hashInt.SetBytes(hash[:]) - isValid := hashInt.Cmp(pow.target) == -1 - return isValid -} diff --git a/pow/sha2bday.go b/pow/sha2bday.go new file mode 100755 index 000000000..4fdd03134 --- /dev/null +++ b/pow/sha2bday.go @@ -0,0 +1,78 @@ +package pow + +import ( + "bytes" + "crypto/sha256" + "encoding/binary" +) + +func checkSha2BDay(proof []byte, nonce, data []byte, diff uint32) bool { + if len(proof) != 24 { + return false + } + prefix1 := proof[:8] + prefix2 := proof[8:16] + prefix3 := proof[16:] + if bytes.Equal(prefix1, prefix2) || bytes.Equal(prefix2, prefix3) || + bytes.Equal(prefix1, prefix3) { + return false + } + resBuf := make([]byte, 32) + h := sha256.New() + h.Write(prefix1) + h.Write(data) + h.Write(nonce) + h.Sum(resBuf[:0]) + res1 := binary.BigEndian.Uint64(resBuf) & ((1 << diff) - 1) + h.Reset() + h.Write(prefix2) + h.Write(data) + h.Write(nonce) + h.Sum(resBuf[:0]) + res2 := binary.BigEndian.Uint64(resBuf) & ((1 << diff) - 1) + h.Reset() + h.Write(prefix3) + h.Write(data) + h.Write(nonce) + h.Sum(resBuf[:0]) + res3 := binary.BigEndian.Uint64(resBuf) & ((1 << diff) - 1) + return res1 == res2 && res2 == res3 +} + +func fulfilSha2BDay(nonce []byte, diff uint32, data []byte) []byte { + // TODO make multithreaded if the difficulty is high enough. + // For light proof-of-work requests, the overhead of parallelizing is + // not worth it. + type Pair struct { + First, Second uint64 + } + var i uint64 = 1 + prefix := make([]byte, 8) + resBuf := make([]byte, 32) + lut := make(map[uint64]Pair) + h := sha256.New() + for { + binary.BigEndian.PutUint64(prefix, i) + h.Write(prefix) + h.Write(data) + h.Write(nonce) + h.Sum(resBuf[:0]) + res := binary.BigEndian.Uint64(resBuf) & ((1 << diff) - 1) + pair, ok := lut[res] + if ok { + if pair.Second != 0 { + ret := make([]byte, 24) + binary.BigEndian.PutUint64(ret, pair.First) + binary.BigEndian.PutUint64(ret[8:], pair.Second) + copy(ret[16:], prefix) + return ret + } + + lut[res] = Pair{First: pair.First, Second: i} + } else { + lut[res] = Pair{First: i} + } + h.Reset() + i++ + } +} diff --git a/proto/identity/identity.go b/proto/identity/identity.go index 5458f348c..a3ab381f9 100644 --- a/proto/identity/identity.go +++ b/proto/identity/identity.go @@ -21,15 +21,17 @@ type MessageType int const ( REGISTER MessageType = iota + ANNOUNCE ) // Returns string name for the MessageType enum func (msgType MessageType) String() string { names := [...]string{ "REGISTER", + "ANNOUNCE", } - if msgType < REGISTER || msgType > REGISTER { + if msgType < REGISTER || msgType > ANNOUNCE { return "Unknown" } return names[msgType] diff --git a/runwait/run_wait.go b/runwait/run_wait.go index b2a953adb..3abebccc4 100644 --- a/runwait/run_wait.go +++ b/runwait/run_wait.go @@ -1,21 +1,20 @@ package main -import "fmt" +import ( + "flag" + "fmt" -// import ( -// "flag" - -// "github.com/simple-rules/harmony-benchmark/p2p" -// "github.com/simple-rules/harmony-benchmark/waitnode" -// ) + "github.com/simple-rules/harmony-benchmark/node" + "github.com/simple-rules/harmony-benchmark/p2p" +) func main() { fmt.Println("hello") - // ip := flag.String("ip", "127.0.0.0", "IP of the node") - // port := flag.String("port", "8080", "port of the node") - // flag.Parse() - // peer := p2p.Peer{Ip: *ip, Port: *port} - // idcpeer := p2p.Peer{Ip: "localhost", Port: "9000"} //Hardcoded here. - // node := waitnode.New(peer) - // node.ConnectIdentityChain(idcpeer) + ip := flag.String("ip", "127.0.0.0", "IP of the node") + port := flag.String("port", "8080", "port of the node") + flag.Parse() + peer := p2p.Peer{Ip: *ip, Port: *port} + idcpeer := p2p.Peer{Ip: "localhost", Port: "9000"} //Hardcoded here. + node := node.NewWaitNode(peer, idcpeer) + node.ConnectIdentityChain() } From c7b63df577f616fbb64f302dcde56d55dc3e9d4e Mon Sep 17 00:00:00 2001 From: ak Date: Tue, 4 Sep 2018 14:42:30 -0700 Subject: [PATCH 2/5] corrected node handler --- node/node_handler.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/node/node_handler.go b/node/node_handler.go index 84c97d323..186c46a45 100644 --- a/node/node_handler.go +++ b/node/node_handler.go @@ -8,8 +8,6 @@ import ( "strconv" "time" - "github.com/simple-rules/harmony-benchmark/log" - "github.com/simple-rules/harmony-benchmark/blockchain" "github.com/simple-rules/harmony-benchmark/p2p" "github.com/simple-rules/harmony-benchmark/proto" From 6632cea6de4e0832833b24dc385ad525ccc29139 Mon Sep 17 00:00:00 2001 From: ak Date: Wed, 5 Sep 2018 23:37:14 -0700 Subject: [PATCH 3/5] working pow --- identitychain/identityblock.go | 12 ++-- identitychain/identitychain.go | 23 ++++---- identitychain/identitychain_handler.go | 77 +++++++++++++++--------- node/node.go | 58 ++++++++++++------ node/node_handler.go | 2 + waitnode/wait_node.go | 82 -------------------------- waitnode/wait_node_test.go | 18 ------ 7 files changed, 107 insertions(+), 165 deletions(-) delete mode 100644 waitnode/wait_node.go delete mode 100644 waitnode/wait_node_test.go diff --git a/identitychain/identityblock.go b/identitychain/identityblock.go index 46be703fe..7a438979e 100644 --- a/identitychain/identityblock.go +++ b/identitychain/identityblock.go @@ -7,8 +7,8 @@ import ( "log" "time" + "github.com/simple-rules/harmony-benchmark/node" "github.com/simple-rules/harmony-benchmark/utils" - "github.com/simple-rules/harmony-benchmark/waitnode" ) // IdentityBlock has the information of one node @@ -16,7 +16,7 @@ type IdentityBlock struct { Timestamp int64 PrevBlockHash [32]byte NumIdentities int32 - Identities []*waitnode.WaitNode + Identities []*node.Node } // Serialize serializes the block @@ -31,7 +31,7 @@ func (b *IdentityBlock) Serialize() []byte { } //Get Identities -func (b *IdentityBlock) GetIdentities() []*waitnode.WaitNode { +func (b *IdentityBlock) GetIdentities() []*node.Node { return b.Identities } @@ -47,7 +47,7 @@ func DeserializeBlock(d []byte) *IdentityBlock { } // NewBlock creates and returns a new block. -func NewBlock(Identities []*waitnode.WaitNode, prevBlockHash [32]byte) *IdentityBlock { +func NewBlock(Identities []*node.Node, prevBlockHash [32]byte) *IdentityBlock { block := &IdentityBlock{Timestamp: time.Now().Unix(), PrevBlockHash: prevBlockHash, NumIdentities: int32(len(Identities)), Identities: Identities} return block } @@ -59,7 +59,7 @@ func (b *IdentityBlock) CalculateBlockHash() [32]byte { hashes = append(hashes, utils.ConvertFixedDataIntoByteArray(b.Timestamp)) hashes = append(hashes, b.PrevBlockHash[:]) for _, id := range b.Identities { - hashes = append(hashes, utils.ConvertFixedDataIntoByteArray(id.ID)) + hashes = append(hashes, utils.ConvertFixedDataIntoByteArray(id)) } hashes = append(hashes, utils.ConvertFixedDataIntoByteArray(b.NumIdentities)) blockHash = sha256.Sum256(bytes.Join(hashes, []byte{})) @@ -68,7 +68,7 @@ func (b *IdentityBlock) CalculateBlockHash() [32]byte { // NewGenesisBlock creates and returns genesis Block. func NewGenesisBlock() *IdentityBlock { - var Ids []*waitnode.WaitNode + var Ids []*node.Node block := &IdentityBlock{Timestamp: time.Now().Unix(), PrevBlockHash: [32]byte{}, NumIdentities: 1, Identities: Ids} return block } diff --git a/identitychain/identitychain.go b/identitychain/identitychain.go index 0af4ba361..d1a9fa012 100644 --- a/identitychain/identitychain.go +++ b/identitychain/identitychain.go @@ -9,8 +9,8 @@ import ( "sync" "github.com/simple-rules/harmony-benchmark/log" + "github.com/simple-rules/harmony-benchmark/node" "github.com/simple-rules/harmony-benchmark/p2p" - "github.com/simple-rules/harmony-benchmark/waitnode" ) var mutex sync.Mutex @@ -19,13 +19,13 @@ var identityPerBlock = 100000 // IdentityChain (Blockchain) keeps Identities per epoch, currently centralized! type IdentityChain struct { Identities []*IdentityBlock - PendingIdentities []*waitnode.WaitNode + PendingIdentities []*node.Node log log.Logger Peer p2p.Peer - SelectedIdentitites []*waitnode.WaitNode + SelectedIdentitites []*node.Node EpochNum int - PeerToShardMap map[*waitnode.WaitNode]int - ShardLeaderMap map[int]*waitnode.WaitNode + PeerToShardMap map[*node.Node]int + ShardLeaderMap map[int]*node.Node PubKey string CurrentEpochStartTime int64 NumberOfShards int @@ -33,7 +33,7 @@ type IdentityChain struct { PowMap map[p2p.Peer]uint32 } -func seekRandomNumber(EpochNum int, SelectedIdentitites []*waitnode.WaitNode) int { +func seekRandomNumber(EpochNum int, SelectedIdentitites []*node.Node) int { // Broadcast message to all nodes and collect back their numbers, do consensus and get a leader. // Use leader to generate a random number. //all here mocked @@ -72,18 +72,18 @@ func (IDC *IdentityChain) CreateShardAssignment() { num := seekRandomNumber(IDC.EpochNum, IDC.SelectedIdentitites) IDC.NumberOfShards = IDC.NumberOfShards + needNewShards() IDC.SelectedIdentitites = generateRandomPermutations(num, IDC.SelectedIdentitites) - IDC.PeerToShardMap = make(map[*waitnode.WaitNode]int) + IDC.PeerToShardMap = make(map[*node.Node]int) numberInOneShard := len(IDC.SelectedIdentitites) / IDC.NumberOfShards for peerNum := 1; peerNum <= len(IDC.SelectedIdentitites); peerNum++ { IDC.PeerToShardMap[IDC.SelectedIdentitites[peerNum]] = peerNum / numberInOneShard } } -func generateRandomPermutations(num int, SelectedIdentitites []*waitnode.WaitNode) []*waitnode.WaitNode { +func generateRandomPermutations(num int, SelectedIdentitites []*node.Node) []*node.Node { src := rand.NewSource(int64(num)) rnd := rand.New(src) perm := rnd.Perm(len(SelectedIdentitites)) - SelectedIdentititesCopy := make([]*waitnode.WaitNode, len(SelectedIdentitites)) + SelectedIdentititesCopy := make([]*node.Node, len(SelectedIdentitites)) for j, i := range perm { SelectedIdentititesCopy[j] = SelectedIdentitites[i] } @@ -98,7 +98,7 @@ func (IDC *IdentityChain) SelectIds() { selectNumber = int(math.Min(float64(len(IDC.PendingIdentities)), float64(selectNumber))) pending := IDC.PendingIdentities[:selectNumber] IDC.SelectedIdentitites = append(currentIDS, pending...) - IDC.PendingIdentities = []*waitnode.WaitNode{} + IDC.PendingIdentities = []*node.Node{} } //Checks how many new shards we need. Currently we say 0. @@ -129,7 +129,7 @@ func (IDC *IdentityChain) UpdateIdentityChain() { prevBlock := IDC.GetLatestBlock() prevBlockHash := prevBlock.CalculateBlockHash() NewIdentities := IDC.PendingIdentities[:identityPerBlock] - IDC.PendingIdentities = []*waitnode.WaitNode{} + IDC.PendingIdentities = []*node.Node{} //All other blocks are dropped, we need to inform them that they are dropped? IDBlock := NewBlock(NewIdentities, prevBlockHash) IDC.Identities = append(IDC.Identities, IDBlock) @@ -171,5 +171,6 @@ func New(Peer p2p.Peer) *IdentityChain { IDC := IdentityChain{} IDC.Peer = Peer IDC.log = log.New() + IDC.PowMap = make(map[p2p.Peer]uint32) return &IDC } diff --git a/identitychain/identitychain_handler.go b/identitychain/identitychain_handler.go index eb9d46326..4e8ac8820 100644 --- a/identitychain/identitychain_handler.go +++ b/identitychain/identitychain_handler.go @@ -7,9 +7,12 @@ import ( "math/rand" "net" "os" + "strconv" + "time" "github.com/simple-rules/harmony-benchmark/node" "github.com/simple-rules/harmony-benchmark/p2p" + "github.com/simple-rules/harmony-benchmark/pow" "github.com/simple-rules/harmony-benchmark/proto" proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity" ) @@ -30,6 +33,8 @@ func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) { if msgCategory != proto.IDENTITY { IDC.log.Error("Identity Chain Recieved incorrect protocol message") os.Exit(1) + } else { + fmt.Println("Message category is correct") } msgType, err := proto.GetMessageType(content) if err != nil { @@ -43,12 +48,20 @@ func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) { } switch msgCategory { case proto.IDENTITY: - actionType := proto_identity.MessageType(msgType) + actionType := proto_identity.IdentityMessageType(msgType) switch actionType { - case proto_identity.REGISTER: - IDC.registerIdentity(msgPayload) - case proto_identity.ANNOUNCE: - IDC.acceptNewConnection(msgPayload) + case proto_identity.IDENTITY: + idMsgType, err := proto_identity.GetIdentityMessageType(msgPayload) + if err != nil { + fmt.Println("Error finding the identity message type") + } + switch idMsgType { + case proto_identity.REGISTER: + IDC.registerIdentity(msgPayload) + case proto_identity.ANNOUNCE: + IDC.acceptNewConnection(msgPayload) + } + } } @@ -61,23 +74,23 @@ func (IDC *IdentityChain) registerIdentity(msgPayload []byte) { } else { fmt.Println("identity payload read") } + fmt.Println("we are now registering identities") //reconstruct the challenge and check whether its correct offset := 0 - //proof := payload[offset : offset+64] - - offset = offset + 64 - Node := node.DeserializeNode(payload[offset:]) - fmt.Println(Node.Self) - os.Exit(1) - // id := []byte(IDC.PowMap[Node.Self]) - // req := pow.NewRequest(5, id) - // ok, _ := pow.Check(req, string(proof), []byte("This is blockchash data")) - // if ok { - // IDC.PendingIdentities = append(IDC.PendingIdentities, Node) - // fmt.Println(len(IDC.PendingIdentities)) //Fix why IDC does not have log working. - // } else { - // fmt.Println("identity proof of work not accepted") - // } + proof := payload[offset : offset+32] + offset = offset + 32 + Node := node.DeserializeWaitNode(payload[offset:]) + id := int(IDC.PowMap[Node.Self]) + req := pow.NewRequest(5, []byte(strconv.Itoa(id))) + ok, err := pow.Check(req, string(proof), []byte("")) + fmt.Println(err) + if ok { + fmt.Println("Proof of work accepted") + IDC.PendingIdentities = append(IDC.PendingIdentities, Node) + fmt.Println(len(IDC.PendingIdentities)) //Fix why IDC does not have log working. + } else { + fmt.Println("identity proof of work not accepted") + } } func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) { @@ -85,19 +98,25 @@ func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) { identityPayload, err := proto_identity.GetIdentityMessagePayload(msgPayload) if err != nil { fmt.Println("There was a error in reading the identity payload") + } else { + fmt.Println("accepted new connection") } - Node := node.DeserializeNode(identityPayload) + fmt.Println("Sleeping for 2 secs ...") + time.Sleep(5 * time.Second) + Node := node.DeserializeWaitNode(identityPayload) buffer := bytes.NewBuffer([]byte{}) - challengeNonce := uint32(rand.Intn(1000)) + src := rand.NewSource(time.Now().UnixNano()) + rnd := rand.New(src) + challengeNonce := uint32(rnd.Int31()) + //challengeNonce := uint32(rand.Intn(1000)) //fix so that different nonce is sent everytime. + fmt.Println("Challenge Nonce Sent:") + fmt.Println(challengeNonce) IDC.PowMap[Node.Self] = challengeNonce + // 4 byte length of challengeNonce - // 64 byte length of challenge - fourBytes := make([]byte, 64) + fourBytes := make([]byte, 4) binary.BigEndian.PutUint32(fourBytes, challengeNonce) buffer.Write(fourBytes) - - sendMsgPayload := buffer.Bytes() - // 32 byte block hash // buffer.Write(prevBlockHash) // The message is missing previous BlockHash, this is because we don't actively maintain a identitychain @@ -106,7 +125,7 @@ func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) { // Message should be encrypted and then signed to follow PKE. //IDC should accept node publickey, encrypt the nonce and blockhash // Then sign the message by own private key and send the message back. - - msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.REGISTER, sendMsgPayload) + fmt.Println("Done sleeping. Ready or not here i come!") + msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.REGISTER, buffer.Bytes()) p2p.SendMessage(Node.Self, msgToSend) } diff --git a/node/node.go b/node/node.go index aad7a9893..f408aa120 100644 --- a/node/node.go +++ b/node/node.go @@ -2,8 +2,11 @@ package node import ( "bytes" + "encoding/binary" "encoding/gob" + "fmt" "net" + "strconv" "sync" "github.com/simple-rules/harmony-benchmark/crypto/pki" @@ -68,6 +71,7 @@ func (node *Node) getTransactionsForNewBlock(maxNumTxs int) ([]*blockchain.Trans // Start a server and process the request by a handler. func (node *Node) StartServer(port string) { + fmt.Println("Hello in server now") node.log.Debug("Starting server", "node", node, "port", port) node.listenOnPort(port) @@ -111,7 +115,8 @@ func (node *Node) countNumTransactionsInBlockchain() int { //ConnectIdentityChain connects to identity chain func (node *Node) ConnectIdentityChain() { IDCPeer := node.IDCPeer - p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.ANNOUNCE, node.SerializeNode())) + p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.ANNOUNCE, node.SerializeWaitNode())) + return } //NewWaitNode is a way to initiate a waiting no @@ -119,6 +124,7 @@ func NewWaitNode(peer, IDCPeer p2p.Peer) Node { node := Node{} node.Self = peer node.IDCPeer = IDCPeer + node.log = log.New() return node } @@ -152,40 +158,54 @@ func NewNodefromIDC(node Node, consensus *consensus.Consensus, db *db.LDBDatabas return &node } -func (node *Node) processPOWMessage(payload []byte) { +func (node *Node) processPOWMessage(message []byte) { + payload, err := identity.GetIdentityMessagePayload(message) + if err != nil { + fmt.Println("Could not read payload") + } IDCPeer := node.IDCPeer offset := 0 - // 4 byte challenge nonce id - req := pow.NewRequest(5, payload[offset:offset+64]) - proof, _ := pow.Fulfil(req, []byte("This is blockchash data")) //"some bound dat" - - proofBytes := make([]byte, 64) - copy(proofBytes[:], proof) + // 4 byte challengeNonce id + challengeNonce := int(binary.BigEndian.Uint32(payload[offset : offset+4])) + offset += 4 + fmt.Println(challengeNonce) + req := pow.NewRequest(5, []byte(strconv.Itoa(challengeNonce))) + proof, _ := pow.Fulfil(req, []byte("")) //"This could be blockhasdata" buffer := bytes.NewBuffer([]byte{}) + proofBytes := make([]byte, 32) //proof seems to be 32 byte here + copy(proofBytes[:], proof) buffer.Write(proofBytes) - - buffer.Write(node.SerializeNode()) - + buffer.Write(node.SerializeWaitNode()) msgPayload := buffer.Bytes() p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.REGISTER, msgPayload)) } +//https://stackoverflow.com/questions/12854125/how-do-i-dump-the-struct-into-the-byte-array-without-reflection/12854659#12854659 //SerializeWaitNode serializes the node -func (node *Node) SerializeNode() []byte { - var result bytes.Buffer - encoder := gob.NewEncoder(&result) - err := encoder.Encode(node) +func (node *Node) SerializeWaitNode() []byte { + //Needs to escape the serialization of unexported fields + result := new(bytes.Buffer) + encoder := gob.NewEncoder(result) + err := encoder.Encode(node.Self) if err != nil { - node.log.Error("Could not serialize node") + fmt.Println("Could not serialize node") + fmt.Println("ERROR", err) + //node.log.Error("Could not serialize node") } + err = encoder.Encode(node.IDCPeer) return result.Bytes() } // DeserializeWaitNode deserializes the node -func DeserializeNode(d []byte) *Node { +func DeserializeWaitNode(d []byte) *Node { var wn Node - decoder := gob.NewDecoder(bytes.NewReader(d)) - err := decoder.Decode(&wn) + r := bytes.NewBuffer(d) + decoder := gob.NewDecoder(r) + err := decoder.Decode(&wn.Self) + if err != nil { + log.Error("Could not de-serialize node") + } + err = decoder.Decode(&wn.IDCPeer) if err != nil { log.Error("Could not de-serialize node") } diff --git a/node/node_handler.go b/node/node_handler.go index 186c46a45..7696241ca 100644 --- a/node/node_handler.go +++ b/node/node_handler.go @@ -3,6 +3,7 @@ package node import ( "bytes" "encoding/gob" + "fmt" "net" "os" "strconv" @@ -63,6 +64,7 @@ func (node *Node) NodeHandler(conn net.Conn) { messageType := proto_identity.MessageType(msgPayload[0]) switch messageType { case proto_identity.REGISTER: + fmt.Println("received a identity message") node.processPOWMessage(msgPayload) case proto_identity.ANNOUNCE: node.log.Error("Announce message should be sent to IdentityChain") diff --git a/waitnode/wait_node.go b/waitnode/wait_node.go deleted file mode 100644 index c66cbe2c9..000000000 --- a/waitnode/wait_node.go +++ /dev/null @@ -1,82 +0,0 @@ -package waitnode - -import ( - "bytes" - "crypto/sha256" - "encoding/gob" - "log" - - "github.com/simple-rules/harmony-benchmark/p2p" - "github.com/simple-rules/harmony-benchmark/utils" -) - -//WaitNode is for nodes waiting to join consensus -type WaitNode struct { - Peer p2p.Peer - ID uint16 - SeedPeers p2p.Peer -} - -// StartServer a server and process the request by a handler. -func (node *WaitNode) StartServer() { - log.Printf("Starting waitnode on server %s and port %s", node.Peer.Ip, node.Peer.Port) -} - -// //ConnectIdentityChain connects to identity chain -// func (node *WaitNode) ConnectIdentityChain(peer p2p.Peer) { -// pow := NewProofOfWork(10) -// nonce := pow.Run() -// if pow.FinalNonce != uint32(nonce) { -// fmt.Println("Something wrong with POW") -// } -// p2p.SendMessage(peer, identity.ConstructIdentityMessage(identity.REGISTER, node.SerializeWaitNode())) -// } - -//Constructs node-id by hashing the IP. -func calculateHash(num string) []byte { - var hashes [][]byte - hashes = append(hashes, utils.ConvertFixedDataIntoByteArray(num)) - hash := sha256.Sum256(bytes.Join(hashes, []byte{})) - return hash[:] -} - -// //SerializePOW serializes the node -// func SerializePOW(pow ProofOfWork) []byte { -// var result bytes.Buffer -// encoder := gob.NewEncoder(&pow) -// err := encoder.Encode(pow) -// if err != nil { -// log.Panic(err.Error()) -// } -// return pow.Bytes() -// } - -//SerializeWaitNode serializes the node -func (node *WaitNode) SerializeWaitNode() []byte { - var result bytes.Buffer - encoder := gob.NewEncoder(&result) - err := encoder.Encode(node) - if err != nil { - log.Panic(err.Error()) - } - return result.Bytes() -} - -// DeserializeWaitNode deserializes the node -func DeserializeWaitNode(d []byte) *WaitNode { - var wn WaitNode - decoder := gob.NewDecoder(bytes.NewReader(d)) - err := decoder.Decode(&wn) - if err != nil { - log.Panic(err) - } - return &wn -} - -// New Create a new Node -func New(Peer p2p.Peer) *WaitNode { - node := WaitNode{} - node.Peer = Peer - node.ID = utils.GetUniqueIdFromPeer(Peer) - return &node -} diff --git a/waitnode/wait_node_test.go b/waitnode/wait_node_test.go deleted file mode 100644 index b7f89ef7d..000000000 --- a/waitnode/wait_node_test.go +++ /dev/null @@ -1,18 +0,0 @@ -package waitnode - -import ( - "testing" - - "github.com/simple-rules/harmony-benchmark/p2p" -) - -func TestNewNode(test *testing.T) { - p := p2p.Peer{Ip: "127.0.0.1", Port: "8080"} - wn := New(p) - b := wn.SerializeWaitNode() - wnd := DeserializeWaitNode(b) - if *wn != *wnd { - test.Error("Serialization is not working") - } - -} From 1da4bd06eaa7c6352d2eee54997176ab9bfecaa2 Mon Sep 17 00:00:00 2001 From: ak Date: Wed, 5 Sep 2018 23:38:16 -0700 Subject: [PATCH 4/5] working pow 2 --- runwait/run_wait.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/runwait/run_wait.go b/runwait/run_wait.go index 3abebccc4..62431c679 100644 --- a/runwait/run_wait.go +++ b/runwait/run_wait.go @@ -9,12 +9,17 @@ import ( ) func main() { - fmt.Println("hello") - ip := flag.String("ip", "127.0.0.0", "IP of the node") + ip := flag.String("ip", "localhost", "IP of the node") port := flag.String("port", "8080", "port of the node") flag.Parse() peer := p2p.Peer{Ip: *ip, Port: *port} idcpeer := p2p.Peer{Ip: "localhost", Port: "9000"} //Hardcoded here. node := node.NewWaitNode(peer, idcpeer) - node.ConnectIdentityChain() + go func() { + node.ConnectIdentityChain() + }() + fmt.Println("control is back with me") + node.StartServer(*port) + fmt.Println("starting the server") + } From c2eb7020c119b6a10a790a405dc501e5615e5753 Mon Sep 17 00:00:00 2001 From: ak Date: Thu, 6 Sep 2018 00:02:38 -0700 Subject: [PATCH 5/5] working pow --- identitychain/identitychain.go | 4 ++-- identitychain/identitychain_handler.go | 23 +++++++---------------- node/node.go | 11 +++-------- 3 files changed, 12 insertions(+), 26 deletions(-) diff --git a/identitychain/identitychain.go b/identitychain/identitychain.go index d1a9fa012..c84cb412d 100644 --- a/identitychain/identitychain.go +++ b/identitychain/identitychain.go @@ -30,7 +30,7 @@ type IdentityChain struct { CurrentEpochStartTime int64 NumberOfShards int NumberOfNodesInShard int - PowMap map[p2p.Peer]uint32 + PowMap map[p2p.Peer]string } func seekRandomNumber(EpochNum int, SelectedIdentitites []*node.Node) int { @@ -171,6 +171,6 @@ func New(Peer p2p.Peer) *IdentityChain { IDC := IdentityChain{} IDC.Peer = Peer IDC.log = log.New() - IDC.PowMap = make(map[p2p.Peer]uint32) + IDC.PowMap = make(map[p2p.Peer]string) return &IDC } diff --git a/identitychain/identitychain_handler.go b/identitychain/identitychain_handler.go index 4e8ac8820..7b004fd2e 100644 --- a/identitychain/identitychain_handler.go +++ b/identitychain/identitychain_handler.go @@ -2,7 +2,6 @@ package identitychain import ( "bytes" - "encoding/binary" "fmt" "math/rand" "net" @@ -80,8 +79,7 @@ func (IDC *IdentityChain) registerIdentity(msgPayload []byte) { proof := payload[offset : offset+32] offset = offset + 32 Node := node.DeserializeWaitNode(payload[offset:]) - id := int(IDC.PowMap[Node.Self]) - req := pow.NewRequest(5, []byte(strconv.Itoa(id))) + req := IDC.PowMap[Node.Self] ok, err := pow.Check(req, string(proof), []byte("")) fmt.Println(err) if ok { @@ -102,30 +100,23 @@ func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) { fmt.Println("accepted new connection") } fmt.Println("Sleeping for 2 secs ...") - time.Sleep(5 * time.Second) + time.Sleep(2 * time.Second) Node := node.DeserializeWaitNode(identityPayload) buffer := bytes.NewBuffer([]byte{}) src := rand.NewSource(time.Now().UnixNano()) rnd := rand.New(src) - challengeNonce := uint32(rnd.Int31()) - //challengeNonce := uint32(rand.Intn(1000)) //fix so that different nonce is sent everytime. - fmt.Println("Challenge Nonce Sent:") - fmt.Println(challengeNonce) - IDC.PowMap[Node.Self] = challengeNonce - // 4 byte length of challengeNonce - - fourBytes := make([]byte, 4) - binary.BigEndian.PutUint32(fourBytes, challengeNonce) - buffer.Write(fourBytes) + challengeNonce := int((rnd.Int31())) + req := pow.NewRequest(5, []byte(strconv.Itoa(challengeNonce))) + IDC.PowMap[Node.Self] = req + fmt.Println(req) + buffer.Write([]byte(req)) // 32 byte block hash // buffer.Write(prevBlockHash) // The message is missing previous BlockHash, this is because we don't actively maintain a identitychain // This canbe included in the fulfill request. - // Message should be encrypted and then signed to follow PKE. //IDC should accept node publickey, encrypt the nonce and blockhash // Then sign the message by own private key and send the message back. - fmt.Println("Done sleeping. Ready or not here i come!") msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.REGISTER, buffer.Bytes()) p2p.SendMessage(Node.Self, msgToSend) } diff --git a/node/node.go b/node/node.go index 3676725c0..35fc1f7a6 100644 --- a/node/node.go +++ b/node/node.go @@ -2,11 +2,9 @@ package node import ( "bytes" - "encoding/binary" "encoding/gob" "fmt" "net" - "strconv" "sync" "github.com/simple-rules/harmony-benchmark/crypto/pki" @@ -155,7 +153,7 @@ func NewNodefromIDC(node Node, consensus *consensus.Consensus, db *db.LDBDatabas node.blockchain = genesisBlock // UTXO pool from Genesis block - node.UtxoPool = blockchain.CreateUTXOPoolFromGenesisBlockChain(node.blockchain) + //node.UtxoPool = blockchain.CreateUTXOPoolFromGenesisBlockChain(node.blockchain) // Initialize level db. node.db = db @@ -173,12 +171,9 @@ func (node *Node) processPOWMessage(message []byte) { fmt.Println("Could not read payload") } IDCPeer := node.IDCPeer - offset := 0 // 4 byte challengeNonce id - challengeNonce := int(binary.BigEndian.Uint32(payload[offset : offset+4])) - offset += 4 - fmt.Println(challengeNonce) - req := pow.NewRequest(5, []byte(strconv.Itoa(challengeNonce))) + req := string(payload) + fmt.Println(req) proof, _ := pow.Fulfil(req, []byte("")) //"This could be blockhasdata" buffer := bytes.NewBuffer([]byte{}) proofBytes := make([]byte, 32) //proof seems to be 32 byte here