Пример #1
0
func (round *RoundStamper) SignatureBroadcast(in *sign.SigningMessage, out []*sign.SigningMessage) error {
	round.RoundCosi.SignatureBroadcast(in, out)
	round.Proof = round.RoundCosi.Cosi.Proof
	round.MTRoot = round.RoundCosi.Cosi.MTRoot

	round.CombProofs = make([]proof.Proof, len(round.StampQueue))
	// Send back signature to clients
	for i, msg := range round.StampQueue {
		// proof to get from s.Root to big root
		combProof := make(proof.Proof, len(round.Proof))
		copy(combProof, round.Proof)

		// add my proof to get from a leaf message to my root s.Root
		combProof = append(combProof, round.StampProofs[i]...)

		// proof that I can get from a leaf message to the big root
		if proof.CheckProof(round.Suite.Hash, round.MTRoot,
			round.StampLeaves[i], combProof) {
			dbg.Lvl2("Proof is OK for msg", msg)
		} else {
			dbg.Lvl2("Inclusion-proof failed")
		}

		round.CombProofs[i] = combProof
	}
	return nil
}
Пример #2
0
// Runs two conodes and tests if the value returned is OK
func TestStamp(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()
	go peer1.LoopRounds(conode.RoundStamperListenerType, 4)
	go peer2.LoopRounds(conode.RoundStamperListenerType, 4)
	time.Sleep(2 * time.Second)

	s, err := conode.NewStamp("testdata/config.toml")
	if err != nil {
		t.Fatal("Couldn't open config-file:", err)
	}

	for _, port := range []int{7000, 7010} {
		stamper := "localhost:" + strconv.Itoa(port)
		dbg.Lvl2("Contacting stamper", stamper)
		tsm, err := s.GetStamp([]byte("test"), stamper)
		dbg.Lvl3("Evaluating results of", stamper)
		if err != nil {
			t.Fatal("Couldn't get stamp from server:", err)
		}

		if !tsm.Srep.AggPublic.Equal(s.X0) {
			t.Fatal("Not correct aggregate public key")
		}
	}

	dbg.Lvl2("Closing peer1")
	peer1.Close()
	dbg.Lvl2("Closing peer2")
	peer2.Close()
	dbg.Lvl3("Done with test")
}
Пример #3
0
// Verifies that the 'message' is included in the signature and that it
// is correct.
// Message is your own hash, and reply contains the inclusion proof + signature
// on the aggregated message
func VerifySignature(suite abstract.Suite, reply *StampSignature, public abstract.Point, message []byte) bool {
	// Check if aggregate public key is correct
	if !public.Equal(reply.AggPublic) {
		dbg.Lvl1("Aggregate-public-key check: FAILED (maybe you have an outdated config file of the tree)")
		return false
	}
	// First check if the challenge is ok
	if err := VerifyChallenge(suite, reply); err != nil {
		dbg.Lvl1("Challenge-check: FAILED (", err, ")")
		return false
	}
	dbg.Lvl2("Challenge-check: OK")

	// Incorporate the timestamp in the message since the verification process
	// is done by reconstructing the challenge
	var b bytes.Buffer
	if err := binary.Write(&b, binary.LittleEndian, reply.Timestamp); err != nil {
		dbg.Lvl1("Error marshaling the timestamp for signature verification")
		return false
	}
	msg := append(b.Bytes(), []byte(reply.MerkleRoot)...)
	if err := VerifySchnorr(suite, msg, public, reply.Challenge, reply.Response); err != nil {
		dbg.Lvl1("Signature-check: FAILED (", err, ")")
		return false
	}
	dbg.Lvl2("Signature-check: OK")

	// finally check the proof
	if !proof.CheckProof(suite.Hash, reply.MerkleRoot, hashid.HashId(message), reply.Prf) {
		dbg.Lvl2("Inclusion-check: FAILED")
		return false
	}
	dbg.Lvl2("Inclusion-check: OK")
	return true
}
Пример #4
0
// Monitor will start listening for incoming connections on this address
// It needs the stats struct pointer to update when measures come
// Return an error if something went wrong during the connection setup
func (m *Monitor) Listen() error {
	ln, err := net.Listen("tcp", Sink+":"+SinkPort)
	if err != nil {
		return fmt.Errorf("Error while monitor is binding address: %v", err)
	}
	m.listener = ln
	dbg.Lvl2("Monitor listening for stats on", Sink, ":", SinkPort)
	finished := false
	go func() {
		for {
			if finished {
				break
			}
			conn, err := ln.Accept()
			if err != nil {
				operr, ok := err.(*net.OpError)
				// We cant accept anymore we closed the listener
				if ok && operr.Op == "accept" {
					break
				}
				dbg.Lvl2("Error while monitor accept connection:", operr)
				continue
			}
			dbg.Lvl3("Monitor: new connection from", conn.RemoteAddr().String())
			m.mutexConn.Lock()
			m.conns[conn.RemoteAddr().String()] = conn
			go m.handleConnection(conn)
			m.mutexConn.Unlock()
		}
	}()
	for !finished {
		select {
		// new stats
		case measure := <-m.measures:
			m.update(measure)
		// end of a peer conn
		case peer := <-m.done:
			dbg.Lvl3("Connections left:", len(m.conns))
			m.mutexConn.Lock()
			delete(m.conns, peer)
			m.mutexConn.Unlock()
			// end of monitoring,
			if len(m.conns) == 0 {
				m.listener.Close()
				finished = true
				break
			}
		}
	}
	dbg.Lvl2("Monitor finished waiting !")
	m.conns = make(map[string]net.Conn)
	return nil
}
Пример #5
0
func main() {
	Current := new(Node)
	Magic := [4]byte{0xF9, 0xBE, 0xB4, 0xD9}
	Current.IP = net.IPv4(0, 1, 2, 3)
	Current.PublicKey = "my_cool_key"
	Current.Last_Block = "0"
	Parser, _ := BitCoSi.NewParser("/home/lefteris/hi/blocks", Magic)
	server := "localhost:2011"
	//	suite = app.GetSuite("25519")

	dbg.Lvl2("Connecting to", server)
	conn := coconet.NewTCPConn(server)
	err := conn.Connect()
	if err != nil {
		dbg.Fatal("Error when getting the connection to the host:", err)
	}
	dbg.Lvl1("Connected to ", server)
	go wait_for_blocks()

	for i := 0; i < 10; i++ {

		Current.transaction_pool = Parser.Parse(i, 10+i)
		for len(Current.transaction_pool) > 0 {
			msg := &BitCoSi.BitCoSiMessage{
				Type:  BitCoSi.TransactionAnnouncmentType,
				ReqNo: 0,
				Treq:  &BitCoSi.TransactionAnnouncment{Val: Current.transaction_pool[0]}}

			err = conn.PutData(msg)
			Current.transaction_pool = Current.transaction_pool[1:]
			if err != nil {
				dbg.Fatal("Couldn't send hash-message to server: ", err)
			}
			time.Sleep(10 * time.Millisecond)

		}
	}

	wait_for_Key_blocks()
	time.Sleep(900000 * time.Millisecond)

	// Asking to close the connection
	err = conn.PutData(&BitCoSi.BitCoSiMessage{
		ReqNo: 1,
		Type:  BitCoSi.BitCoSiClose,
	})

	conn.Close()
	dbg.Lvl2("Connection closed with server")

}
Пример #6
0
// The core of the file: read any input from the connection and outputs it into
// the server connection
func proxyConnection(conn net.Conn, done chan bool) {
	dec := json.NewDecoder(conn)
	nerr := 0
	for {
		m := Measure{}
		// Receive data
		if err := dec.Decode(&m); err != nil {
			if err == io.EOF {
				break
			}
			dbg.Lvl1("Error receiving data from", conn.RemoteAddr().String(), ":", err)
			nerr += 1
			if nerr > 1 {
				dbg.Lvl1("Too many errors from", conn.RemoteAddr().String(), ": Abort connection")
				break
			}
		}
		dbg.Lvl3("Proxy received", m)

		// Implement our own ready-count, so it doesn't have to go through the
		// main monitor which might be far away.
		switch m.Name {
		case "ready":
			atomic.AddInt64(&readyCount, 1)
		case "ready_count":
			m.Ready = int(readyCount)
			err := json.NewEncoder(conn).Encode(m)
			if err != nil {
				dbg.Lvl2("Couldn't send ready-result back to client")
				break
			}
		default:
			// Proxy data - add who is sending, as we only have one channel
			// to the server
			m.Sender = conn.RemoteAddr().String()
			if err := serverEnc.Encode(m); err != nil {
				dbg.Lvl2("Error proxying data :", err)
				break
			}
			if m.Name == "end" {
				// the end
				dbg.Lvl2("Proxy detected end of measurement. Closing connection.")
				break
			}
		}
	}
	conn.Close()
	done <- true
}
Пример #7
0
func main() {
	deter.ReadConfig()
	// The flags are defined in lib/app
	app.FlagInit()
	flag.Parse()

	setup_deter()

	var wg sync.WaitGroup
	virts := physToServer[app.RunFlags.PhysAddr]
	if len(virts) > 0 {
		dbg.Lvl3("starting", len(virts), "servers of", deter.App, "on", virts)
		for _, name := range virts {
			dbg.Lvl3("Starting", name, "on", app.RunFlags.PhysAddr)
			wg.Add(1)
			go func(nameport string) {
				dbg.Lvl3("Running on", app.RunFlags.PhysAddr, "starting", nameport, rootname)
				defer wg.Done()

				amroot := nameport == rootname
				args := []string{
					"-hostname=" + nameport,
					"-physaddr=" + app.RunFlags.PhysAddr,
					"-amroot=" + strconv.FormatBool(amroot),
					"-test_connect=" + strconv.FormatBool(testConnect),
					"-logger=" + app.RunFlags.Logger,
					"-mode=server",
				}

				dbg.Lvl3("Starting on", app.RunFlags.PhysAddr, "with args", args)
				cmdApp := exec.Command("./"+deter.App, args...)
				cmdApp.Stdout = os.Stdout
				cmdApp.Stderr = os.Stderr
				err := cmdApp.Run()
				if err != nil {
					dbg.Lvl1("cmd run:", err)
				}

				dbg.Lvl3("Finished with app", app.RunFlags.PhysAddr)
			}(name)
		}
		dbg.Lvl3(app.RunFlags.PhysAddr, "Finished starting apps")
		wg.Wait()
	} else {
		dbg.Lvl2("No apps for", app.RunFlags.PhysAddr)
	}
	dbg.Lvl2(app.RunFlags.PhysAddr, "forkexec exited")
}
Пример #8
0
// LoopRounds starts the system by sending a round of type
// 'roundType' every second for number of 'rounds'.
// If 'rounds' < 0, it loops forever, or until you call
// peer.Close().
func (peer *Peer) LoopRounds(roundType string, rounds int) {
	dbg.Lvl3("Stamp-server", peer.Node.Name(), "starting with IsRoot=", peer.IsRoot(peer.ViewNo))
	ticker := time.NewTicker(sign.ROUND_TIME)
	firstRound := peer.Node.LastRound()
	if !peer.IsRoot(peer.ViewNo) {
		// Children don't need to tick, only the root.
		ticker.Stop()
	}

	for {
		select {
		case nextRole := <-peer.ViewChangeCh():
			dbg.Lvl2(peer.Name(), "assuming next role is", nextRole)
		case <-peer.CloseChan:
			dbg.Lvl3("Server-peer", peer.Name(), "has closed the connection")
			return
		case <-ticker.C:
			dbg.Lvl3("Ticker is firing in", peer.Hostname)
			roundNbr := peer.LastRound() - firstRound
			if roundNbr >= rounds && rounds >= 0 {
				dbg.Lvl3(peer.Name(), "reached max round: closing",
					roundNbr, ">=", rounds)
				ticker.Stop()
				if peer.IsRoot(peer.ViewNo) {
					dbg.Lvl3("As I'm root, asking everybody to terminate")
					peer.SendCloseAll()
				}
			} else {
				if peer.IsRoot(peer.ViewNo) {
					dbg.Lvl2(peer.Name(), "Stamp server in round",
						roundNbr+1, "of", rounds)
					round, err := sign.NewRoundFromType(roundType, peer.Node)
					if err != nil {
						dbg.Fatal("Couldn't create", roundType, err)
					}
					err = peer.StartAnnouncement(round)
					if err != nil {
						dbg.Lvl3(err)
						time.Sleep(1 * time.Second)
						break
					}
				} else {
					dbg.Lvl3(peer.Name(), "running as regular")
				}
			}
		}
	}
}
Пример #9
0
// For testing the different round-types
// Every round-type is in his own Test*-method,
// so one can easily run just a given round-test
func testRound(t *testing.T, roundType string) {
	dbg.TestOutput(testing.Verbose(), 4)
	dbg.Lvl2("Testing", roundType)
	peer1, peer2 := createPeers()

	round, err := sign.NewRoundFromType(roundType, peer1.Node)
	if err != nil {
		t.Fatal("Couldn't create", roundType, "round:", err)
	}

	peer1.StartAnnouncement(round)
	time.Sleep(time.Second)

	var cosi *sign.CosiStruct
	switch roundType {
	case sign.RoundCosiType:
		cosi = round.(*sign.RoundCosi).Cosi
	case sign.RoundExceptionType:
		cosi = round.(*sign.RoundException).Cosi
	case conode.RoundStamperType:
		cosi = round.(*conode.RoundStamper).Cosi
	case conode.RoundStamperListenerType:
		cosi = round.(*conode.RoundStamperListener).Cosi
	}
	if cosi.R_hat == nil {
		t.Fatal("Didn't finish round - R_hat empty")
	}
	err = cosi.VerifyResponses()
	if err != nil {
		t.Fatal("Couldn't verify responses")
	}

	peer1.Close()
	peer2.Close()
}
Пример #10
0
// GetStamp contacts the "server" and waits for the "msg" to
// be signed
// If server is empty, it will contact one randomly
func (s *Stamp) GetStamp(msg []byte, server string) (*TimeStampMessage, error) {
	if server == "" {
		server = s.Config.Hosts[rand.Intn(len(s.Config.Hosts))]
	}
	dbg.Lvl2("StampClient will stamp on server", server)
	portstr := strconv.Itoa(cliutils.GetPort(server, DefaultPort) + 1)
	err := s.connect(cliutils.GetAddress(server) + ":" + portstr)
	if err != nil {
		return nil, err
	}

	tsm, err := s.stamp(msg)
	if err != nil {
		return nil, err
	}

	err = s.disconnect()
	if err != nil {
		return nil, err
	}

	// Verify if what we received is correct
	if !VerifySignature(s.Suite, tsm.Srep, s.X0, msg) {
		return nil, fmt.Errorf("Verification of signature failed")
	}

	return tsm, nil
}
Пример #11
0
// ConnectTo will connect to the given host and start the SYN exchange (public key + id)
func (p *Peer) ConnectTo(host string) error {
	tick := time.NewTicker(ConnWaitRetry)
	count := 0
	for range tick.C {
		// connect
		conn, err := net.Dial("tcp", host)
		if err != nil {
			// we have tried too many times => abort
			if count == ConnRetry {
				tick.Stop()
				dbg.Fatal(p.Name, "could not connect to", host, "", ConnRetry, "times. Abort.")
				// let's try again one more time
			} else {
				dbg.Lvl2(p.Name, "could not connect to", host, ". Retry in", ConnWaitRetry.String())
				count += 1
			}
		}
		// handle successful connection
		dbg.Lvl3(p.Name, "has connected with peer", host)
		tick.Stop()
		// start to syn with the respective peer
		go p.synWithPeer(conn)
		break
	}
	return nil
}
Пример #12
0
func (round *RoundStamperListener) SignatureBroadcast(in *sign.SigningMessage, out []*sign.SigningMessage) error {
	round.RoundStamper.SignatureBroadcast(in, out)
	if round.IsRoot {
		in.SBm.Messages = round.roundMessages
	}
	for _, o := range out {
		o.SBm.Messages = in.SBm.Messages
	}
	for i, msg := range round.ClientQueue {
		respMessg := &TimeStampMessage{
			Type:  StampSignatureType,
			ReqNo: SeqNo(msg.ReqNo),
			Srep: &StampSignature{
				SuiteStr:   round.Suite.String(),
				Timestamp:  round.Timestamp,
				MerkleRoot: round.MTRoot,
				Prf:        round.RoundStamper.CombProofs[i],
				Response:   in.SBm.R0_hat,
				Challenge:  in.SBm.C,
				AggCommit:  in.SBm.V0_hat,
				AggPublic:  in.SBm.X0_hat,
			}}
		round.PutToClient(msg.To, respMessg)
		dbg.Lvl2("Sent signature response back to client", msg.To)
	}
	return nil
}
Пример #13
0
// Filter out a serie of values
func (df *DataFilter) Filter(measure string, values []float64) []float64 {
	// do we have a filter for this measure ?
	if _, ok := df.percentiles[measure]; !ok {
		return values
	}
	// Compute the percentile value
	max, err := stats.PercentileNearestRank(values, df.percentiles[measure])
	if err != nil {
		dbg.Lvl2("Monitor: Error filtering data:", err)
		return values
	}

	// Find the index from where to filter
	maxIndex := -1
	for i, v := range values {
		if v > max {
			maxIndex = i
		}
	}
	// check if we foud something to filter out
	if maxIndex == -1 {
		dbg.Lvl3("Filtering: nothing to filter for", measure)
		return values
	}
	// return the values below the percentile
	dbg.Lvl3("Filtering: filters out", measure, ":", maxIndex, "/", len(values))
	return values[:maxIndex]
}
Пример #14
0
func (sn *Node) CloseAll(view int) error {
	dbg.Lvl2(sn.Name(), "received CloseAll on", view)

	// At the leaves
	if len(sn.Children(view)) == 0 {
		dbg.Lvl3(sn.Name(), "in CloseAll is root leaf")
	} else {
		dbg.Lvl3(sn.Name(), "in CloseAll is calling", len(sn.Children(view)), "children")

		// Inform all children of announcement
		messgs := make([]coconet.BinaryMarshaler, sn.NChildren(view))
		for i := range messgs {
			sm := SigningMessage{
				Suite:   sn.Suite().String(),
				Type:    CloseAll,
				ViewNbr: view,
				//LastSeenVote: int(atomic.LoadInt64(&sn.LastSeenVote)),
			}
			messgs[i] = &sm
		}
		ctx := context.TODO()
		if err := sn.PutDown(ctx, view, messgs); err != nil {
			return err
		}
	}
	dbg.Lvl3("Closing down shop", sn.Isclosed)
	sn.Close()
	return nil
}
Пример #15
0
// Checks the correct setup of the signature
func TestsetupTestSig(t *testing.T) {
	setupTestSig()
	if !reply.AggPublic.Equal(X0) {
		t.Error("X0 is not equal")
	} else {
		dbg.Lvl2("X0 is OK")
	}
}
Пример #16
0
func readConfig() *app.ConfigConode {
	conf := &app.ConfigConode{}
	if err := app.ReadTomlConfig(conf, "testdata/config.toml"); err != nil {
		dbg.Fatal("Could not read toml config... : ", err)
	}
	dbg.Lvl2("Configuration file read")
	suite = app.GetSuite(conf.Suite)
	return conf
}
Пример #17
0
// Verifies whether the X0 and hash is correct
func TestVerifySignature(t *testing.T) {
	setupTestSig()

	if !conode.VerifySignature(suite, &reply, X0, hash) {
		t.Error("Verification failed")
	} else {
		dbg.Lvl2("Verification passed")
	}
}
Пример #18
0
func (sn *Node) ShouldIFail(phase string) bool {
	if sn.FailureRate > 0 {
		// If we were manually set to always fail
		if sn.Host.(*coconet.FaultyHost).IsDead() ||
			sn.Host.(*coconet.FaultyHost).IsDeadFor(phase) {
			dbg.Lvl2(sn.Name(), "dead for "+phase)
			return true
		}

		// If we were only given a probability of failing
		if p := sn.Rand.Int() % 100; p < sn.FailureRate {
			dbg.Lvl2(sn.Name(), "died for "+phase, "p", p, "with prob", sn.FailureRate)
			return true
		}

	}

	return false
}
Пример #19
0
// StopMonitor will close every connections it has
// And will stop updating the stats
func (m *Monitor) Stop() {
	dbg.Lvl2("Monitor Stop")
	m.listener.Close()
	m.mutexConn.Lock()
	for _, c := range m.conns {
		c.Close()
	}
	m.mutexConn.Unlock()

}
Пример #20
0
// Verifies whether the Challenge is correct
func TestVerifyChallenge(t *testing.T) {
	setupTestSig()

	err := conode.VerifyChallenge(suite, &reply)
	if err != nil {
		t.Error("Verification failed")
	} else {
		dbg.Lvl2("Verification passed")
	}
}
Пример #21
0
// SImply adds all the public keys we give to it
func aggregateKeys(pubs []string) abstract.Point {
	k0 := suite.Point().Null()
	for i, ki := range pubs {
		// convert from string to public key
		kip, _ := cliutils.ReadPub64(suite, strings.NewReader(ki))
		k0 = k0.Add(k0, kip)
		dbg.Lvl2("Public key n#", i, ":", kip)
	}
	dbg.Lvl1("Aggregated public key:", k0)
	return k0
}
Пример #22
0
// Returns name of node who should be the root for the next view
// round robin is used on the array of host names to determine the next root
func (sn *Node) RootFor(view int) string {
	dbg.Lvl2(sn.Name(), "Root for view", view)
	var hl []string
	if view == 0 {
		hl = sn.HostListOn(view)
	} else {
		// we might not have the host list for current view
		// safer to use the previous view's hostlist, always
		hl = sn.HostListOn(view - 1)
	}
	return hl[view%len(hl)]
}
Пример #23
0
func ExampleLevel2() {
	dbg.DebugVisible = 2
	dbg.Lvl1("Level1")
	dbg.Lvl2("Level2")
	dbg.Lvl3("Level3")
	dbg.Lvl4("Level4")
	dbg.Lvl5("Level5")

	// Output:
	// 1: (                  dbg_test.ExampleLevel2:   0) - Level1
	// 2: (                  dbg_test.ExampleLevel2:   0) - Level2
}
Пример #24
0
func (round *RoundSetup) Commitment(in []*SigningMessage, out *SigningMessage) error {
	out.Com.Messages = 1
	if !round.IsLeaf {
		for _, i := range in {
			out.Com.Messages += i.Com.Messages
		}
	}
	if round.IsRoot {
		dbg.Lvl2("Number of nodes found:", out.Com.Messages)
		round.Counted <- out.Com.Messages
	}
	return nil
}
Пример #25
0
// handleConnection will decode the data received and aggregates it into its
// stats
func (m *Monitor) handleConnection(conn net.Conn) {
	dec := json.NewDecoder(conn)
	enc := json.NewEncoder(conn)
	nerr := 0
	for {
		measure := Measure{}
		if err := dec.Decode(&measure); err != nil {
			// if end of connection
			if err == io.EOF {
				break
			}
			// otherwise log it
			dbg.Lvl2("Error monitor decoding from", conn.RemoteAddr().String(), ":", err)
			nerr += 1
			if nerr > 1 {
				dbg.Lvl2("Monitor: too many errors from", conn.RemoteAddr().String(), ": Abort.")
				break
			}
		}

		dbg.Lvlf3("Monitor: received a Measure from %s: %+v", conn.RemoteAddr().String(), measure)
		// Special case where the measurement is indicating a FINISHED step
		switch strings.ToLower(measure.Name) {
		case "end":
			dbg.Lvl3("Finishing monitor")
			m.done <- conn.RemoteAddr().String()
		case "ready":
			m.stats.Ready++
			dbg.Lvl3("Increasing counter to", m.stats.Ready)
		case "ready_count":
			dbg.Lvl3("Sending stats")
			m_send := measure
			m_send.Ready = m.stats.Ready
			enc.Encode(m_send)
		default:
			m.measures <- measure
		}
	}
}
Пример #26
0
// Will build the application
func (d *Localhost) Build(build string) error {
	src, _ := filepath.Rel(d.LocalDir, d.AppDir+"/"+d.App)
	dst := d.RunDir + "/" + d.App
	start := time.Now()
	// build for the local machine
	res, err := cliutils.Build(src, dst, runtime.GOARCH, runtime.GOOS)
	if err != nil {
		dbg.Fatal("Error while building for localhost (src", src, ", dst", dst, ":", res)
	}
	dbg.Lvl3("Localhost: Build src", src, ", dst", dst)
	dbg.Lvl3("Localhost: Results of localhost build:", res)
	dbg.Lvl2("Localhost: build finished in", time.Since(start))
	return err
}
Пример #27
0
// Verifies whether the Schnorr signature is correct
func TestVerifySchnorr(t *testing.T) {
	setupTestSig()
	var b bytes.Buffer
	if err := binary.Write(&b, binary.LittleEndian, reply.Timestamp); err != nil {
		dbg.Lvl1("Error marshaling the timestamp for signature verification")
	}
	msg := append(b.Bytes(), []byte(reply.MerkleRoot)...)
	err := conode.VerifySchnorr(suite, msg, X0, reply.Challenge, reply.Response)
	if err != nil {
		dbg.Fatal("Schnorr verification failed")
	} else {
		dbg.Lvl2("Schnorr OK")
	}
}
Пример #28
0
func wait_for_blocks() {

	server := "localhost:2011"
	suite = app.GetSuite("25519")

	dbg.Lvl2("Connecting to", server)
	conn := coconet.NewTCPConn(server)
	err := conn.Connect()
	if err != nil {
		dbg.Fatal("Error when getting the connection to the host:", err)
	}
	dbg.Lvl1("Connected to ", server)
	for i := 0; i < 1000; i++ {
		time.Sleep(1 * time.Second)
		msg := &BitCoSi.BitCoSiMessage{
			Type:  BitCoSi.BlockRequestType,
			ReqNo: 0,
		}

		err = conn.PutData(msg)
		if err != nil {
			dbg.Fatal("Couldn't send hash-message to server: ", err)
		}
		dbg.Lvl1("Sent signature request")
		// Wait for the signed message

		tsm := new(BitCoSi.BitCoSiMessage)
		tsm.Brep = &BitCoSi.BlockReply{}
		tsm.Brep.SuiteStr = suite.String()
		err = conn.GetData(tsm)
		if err != nil {
			dbg.Fatal("Error while receiving signature:", err)
		}
		//dbg.Lvlf1("Got signature response %+v", tsm.Brep)

		T := new(BitCoSi.TrBlock)
		T.Block = tsm.Brep.Block
		T.Print()
		dbg.Lvlf1("Response %v ", tsm.Brep.Response)
	}
	// Asking to close the connection
	err = conn.PutData(&BitCoSi.BitCoSiMessage{
		ReqNo: 1,
		Type:  BitCoSi.BitCoSiClose,
	})

	conn.Close()

}
Пример #29
0
// Update will update the Stats with this given measure
func (s *Stats) Update(m Measure) {
	var meas *Measurement
	meas, ok := s.measures[m.Name]
	if !ok {
		// if we already written some values, we can not take new ones
		if s.valuesWritten {
			dbg.Lvl2("Stats Update received unknown type of measure:", m.Name)
			return
		}
		meas = NewMeasurement(m.Name, s.filter)
		s.measures[m.Name] = meas
		s.keys = append(s.keys, m.Name)
	}
	meas.Update(m)
}
Пример #30
0
// returns a tuple of start and stop configurations to run
func getStartStop(rcs int) (int, int) {
	ss_str := strings.Split(simRange, ":")
	start, err := strconv.Atoi(ss_str[0])
	stop := rcs
	if err == nil {
		stop = start
		if len(ss_str) > 1 {
			stop, err = strconv.Atoi(ss_str[1])
			if err != nil {
				stop = rcs
			}
		}
	}
	dbg.Lvl2("Range is", start, "...", stop)
	return start, stop
}