Example #1
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()
}
Example #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")
}
Example #3
0
func TestMonitor(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 2)
	m := make(map[string]string)
	m["machines"] = "1"
	m["ppm"] = "1"
	stat := NewStats(m)
	fresh := stat.String()
	// First set up monitor listening
	mon := NewMonitor(stat)
	go mon.Listen()
	time.Sleep(100 * time.Millisecond)

	// Then measure
	err := ConnectSink("localhost:" + SinkPort)
	if err != nil {
		t.Error(fmt.Sprintf("Error starting monitor: %s", err))
		return
	}

	meas := NewMeasure("round")
	meas.Measure()
	time.Sleep(200 * time.Millisecond)
	meas.Measure()
	End()
	time.Sleep(100 * time.Millisecond)
	updated := stat.String()
	if updated == fresh {
		t.Error("Stats not updated ?")
	}

	StopSink()
}
Example #4
0
// Make sure closeall sends messages to everybody
func TestCloseAll(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()

	// Launch peers in endless loop
	go peer1.LoopRounds(sign.RoundCosiType, -1)
	go peer2.LoopRounds(sign.RoundCosiType, -1)

	// Send CloseAll manually
	peer1.SendCloseAll()
	time.Sleep(time.Second)
	if !peer1.Closed {
		t.Fatal("Peer 1 should be closed now.")
	}
	if !peer2.Closed {
		t.Fatal("Peer 2 should be closed now.")
	}

	// Now let's just wait for two rounds
	peer1, peer2 = createPeers()
	go peer1.LoopRounds(sign.RoundCosiType, 2)
	go peer2.LoopRounds(sign.RoundCosiType, 2)
	time.Sleep(time.Second * 4)
	if !peer1.Closed {
		t.Fatal("Peer 1 should be closed now.")
	}
	if !peer2.Closed {
		t.Fatal("Peer 2 should be closed now.")
	}
}
Example #5
0
// Tests if the rounds are deleted when done
func TestDeleteRounds(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()

	if len(peer1.Rounds) != 0 {
		t.Fatal("There should be 0 rounds to start with")
	}

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

	peer1.StartAnnouncement(round)
	if len(peer1.Rounds) != 1 {
		t.Fatal("Created one round - should be there")
	}

	time.Sleep(time.Second)

	if len(peer1.Rounds) != 0 {
		t.Fatal("Doing one round shouldn't take more than 1 second")
	}

	peer1.Close()
	peer2.Close()
}
Example #6
0
func TestSigScanner(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	signame := "/tmp/sigs.txt"
	ioutil.WriteFile(signame, []byte(TestFileSignatures), 0660)
	blocks, err := SigScanner(signame)
	if err != nil {
		t.Fatal("Error while parsing blocks:", err)
	}

	dbg.Printf("%+v", blocks)
}
Example #7
0
func TestPolicyScanner(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	polname := "/tmp/policy.txt"
	ioutil.WriteFile(polname, []byte(TestFilePolicy), 0660)
	thres, devkeys, cothkey, err := PolicyScanner(polname)
	if err != nil {
		t.Fatal("Error while parsing blocks:", err)
	}

	dbg.Printf("%+v\n %+v\n %+v\n", thres, devkeys, cothkey)
}
Example #8
0
func TestReadyProxy(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 3)
	m := make(map[string]string)
	m["machines"] = "1"
	m["ppm"] = "1"
	stat := NewStats(m)
	// First set up monitor listening
	monitor := NewMonitor(stat)
	done := make(chan bool)
	go func() {
		monitor.Listen()
		done <- true
	}()
	time.Sleep(100 * time.Millisecond)
	// Then setup proxy
	// change port so the proxy does not listen to the same
	// than the original monitor
	oldSink := SinkPort
	SinkPort = "8000"
	// proxy listen to 0.0.0.0:8000 & redirect to
	// localhost:4000
	go Proxy("localhost:" + oldSink)

	time.Sleep(100 * time.Millisecond)
	// Then measure
	proxyAddr := "localhost:" + SinkPort
	err := ConnectSink(proxyAddr)
	if err != nil {
		t.Error(fmt.Sprintf("Can not connect to proxy : %s", err))
		return
	}

	s, err := GetReady(proxyAddr)
	if err != nil {
		t.Error("Couldn't get stats from proxy")
	}
	if s.Ready != 0 {
		t.Error("stats.Ready should be 0")
	}
	Ready(proxyAddr)
	s, err = GetReady(proxyAddr)
	if err != nil {
		t.Error("Couldn't get stats from proxy")
	}
	if s.Ready != 1 {
		t.Error("stats.Ready should be 1")
	}

	SinkPort = oldSink
	End()
	StopSink()
}
Example #9
0
// What happens if client closes before server does?
func TestClientBeforeServer(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()

	peer2.Close()
	time.Sleep(time.Second)

	round, err := sign.NewRoundFromType(sign.RoundCosiType, peer1.Node)
	if err != nil {
		t.Fatal("Error while creating round:", err)
	}

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

	peer1.Close()
}
Example #10
0
func TestVerification(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	var (
		PolicyFile     = "example/policy.txt"
		SignaturesFile = "example/signatures.txt"
		CommitIdFile   = "example/commitid.txt"
	)

	commitId, _ := CommitScanner(CommitIdFile)
	decision, err := ApprovalCheck(PolicyFile, SignaturesFile, commitId)
	if err != nil {
		dbg.Panic("Problem with verifying approval of developers", err)
	}

	// dbg.Printf("How many signatures have been read? %+v", len(co.Signatures))
	// dbg.Printf("What is a threshold value? %+v", co.Policy.Threshold)
	dbg.Printf("Is commit approved? %+v", decision)
}
Example #11
0
func TestReadyNormal(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 3)
	m := make(map[string]string)
	m["machines"] = "1"
	m["ppm"] = "1"
	m["Ready"] = "0"
	stat := NewStats(m)
	if stat.Ready != 0 {
		t.Fatal("Stats should start with ready==0")
	}
	// First set up monitor listening
	mon := NewMonitor(stat)
	go mon.Listen()
	time.Sleep(100 * time.Millisecond)
	host := "localhost:" + SinkPort
	if stat.Ready != 0 {
		t.Fatal("Stats should have ready==0 after start of Monitor")
	}

	s, err := GetReady(host)
	if err != nil {
		t.Fatal("Couldn't get number of peers:", err)
	}
	if s.Ready != 0 {
		t.Fatal("Stats.Ready != 0")
	}

	err = Ready(host)
	if err != nil {
		t.Errorf("Error starting monitor: %s", err)
		return
	}

	s, err = GetReady(host)
	if err != nil {
		t.Fatal("Couldn't get number of peers:", err)
	}
	if s.Ready != 1 {
		t.Fatal("Stats.Ready != 1")
	}

	End()
	StopSink()
}
Example #12
0
// Can we build the Peer without a valid key?
func TestEmptyKeys(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	conf1 := readConfig()
	emptyKeys(conf1.Tree)
	peer1 := createPeer(conf1, 1)
	dbg.Lvlf3("Peer 1 is %+v", peer1)

	conf2 := readConfig()
	emptyKeys(conf2.Tree)
	peer2 := createPeer(conf2, 1)
	dbg.Lvlf3("Peer 1 is %+v", peer2)

	go peer1.LoopRounds(sign.RoundCosiType, 2)
	go peer2.LoopRounds(sign.RoundCosiType, 2)

	time.Sleep(time.Second * 2)

	peer1.Close()
	peer2.Close()
}
Example #13
0
func TestStampListener(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()

	round1 := conode.NewRoundStamperListener(peer1.Node)
	round2, err := sign.NewRoundFromType(conode.RoundStamperListenerType, peer1.Node)

	if err != nil {
		dbg.Fatal("Error when creating round:", err)
	}

	dbg.Lvlf2("Round1: %+v", round1)
	dbg.Lvlf2("Round2: %+v", round2)
	name1, name2 := round1.Name, round2.(*conode.RoundStamperListener).Name
	if name1 != name2 {
		t.Fatal("Hostname of first round is", name1, "and should be equal to", name2)
	}
	peer1.Close()
	peer2.Close()
}
Example #14
0
func TestKeyOrder(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 3)
	m := make(map[string]string)
	m["machines"] = "1"
	m["ppm"] = "1"
	m["bf"] = "2"
	m["rounds"] = "3"

	for i := 0; i < 20; i++ {
		// First set up monitor listening
		stat := NewStats(m)
		NewMonitor(stat)
		time.Sleep(100 * time.Millisecond)
		b := bytes.NewBuffer(make([]byte, 1024))
		stat.WriteHeader(b)
		dbg.Lvl2("Order:", strings.TrimSpace(b.String()))
		if strings.Contains(b.String(), "rounds, bf") {
			t.Fatal("Order of fields is not correct")
		}
	}
}
Example #15
0
func TestRoundSetup(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	roundType := "setup"
	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)

	counted := <-round.(*sign.RoundSetup).Counted
	if counted != 2 {
		t.Fatal("Counted", counted, "nodes, but should be 2")
	}

	peer1.Close()
	peer2.Close()
}
Example #16
0
func TestMakeConfig(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 2)
	os.Chdir("/tmp")
	KeyGeneration("key1", "localhost:2000")
	KeyGeneration("key2", "localhost:2010")
	key1, _ := ioutil.ReadFile("key1.pub")
	key2, _ := ioutil.ReadFile("key2.pub")
	ioutil.WriteFile("hosts", []byte(fmt.Sprintf("%s%s", key1, key2)), 0666)
	Build("hosts", 2, "config.toml")

	wg := sync.WaitGroup{}
	wg.Add(2)
	maxRounds = 3
	go (func() {
		Run("config.toml", "key1")
		wg.Done()
	})()
	go (func() {
		Run("config.toml", "key2")
		wg.Done()
	})()
	wg.Wait()
}
Example #17
0
func TestReadRunfile(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 2)
	tplat := &TPlat{}

	tmpfile := "/tmp/testrun.toml"
	err := ioutil.WriteFile(tmpfile, []byte(testfile), 0666)
	if err != nil {
		dbg.Fatal("Couldn't create file:", err)
	}

	tests := platform.ReadRunFile(tplat, tmpfile)
	dbg.Lvl2(tplat)
	dbg.Lvlf2("%+v\n", tests[0])
	if tplat.App != "sign" {
		dbg.Fatal("App should be 'sign'")
	}
	if len(tests) != 2 {
		dbg.Fatal("There should be 2 tests")
	}
	if tests[0].Get("machines") != "8" {
		dbg.Fatal("Machines = 8 has not been copied into RunConfig")
	}
}
Example #18
0
func TestRoundException(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 4)
	peer1, peer2 := createPeers()
	sign.ExceptionForceFailure = peer2.Name()

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

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

	cosi := round.(*sign.RoundException).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()
}
Example #19
0
func TestProxy(t *testing.T) {
	dbg.TestOutput(testing.Verbose(), 3)
	m := make(map[string]string)
	m["machines"] = "1"
	m["ppm"] = "1"
	m["filter_round"] = "100"
	stat := NewStats(m)
	fresh := stat.String()
	// First set up monitor listening
	monitor := NewMonitor(stat)
	done := make(chan bool)
	go func() {
		monitor.Listen()
		done <- true
	}()
	time.Sleep(100 * time.Millisecond)
	// Then setup proxy
	// change port so the proxy does not listen to the same
	// than the original monitor
	oldSink := SinkPort
	SinkPort = "8000"
	// proxy listen to 0.0.0.0:8000 & redirect to
	// localhost:4000
	go Proxy("localhost:" + oldSink)

	time.Sleep(100 * time.Millisecond)
	// Then measure
	proxyAddr := "localhost:" + SinkPort
	err := ConnectSink(proxyAddr)
	if err != nil {
		t.Error(fmt.Sprintf("Can not connect to proxy : %s", err))
		return
	}

	meas := NewMeasure("setup")
	meas.Measure()
	time.Sleep(100 * time.Millisecond)
	meas.Measure()

	s, err := GetReady(proxyAddr)
	if err != nil {
		t.Error("Couldn't get stats from proxy")
	}
	if s.Ready != 0 {
		t.Error("stats.Ready should be 0")
	}
	Ready(proxyAddr)
	s, err = GetReady(proxyAddr)
	if err != nil {
		t.Error("Couldn't get stats from proxy")
	}
	if s.Ready != 1 {
		t.Error("stats.Ready should be 1")
	}

	SinkPort = oldSink
	End()
	StopSink()
	select {
	case <-done:
		s := monitor.Stats()
		s.Collect()
		if s.String() == fresh {
			t.Error("stats not updated?")
		}
		return
	case <-time.After(2 * time.Second):
		t.Error("Monitor not finished")
	}
}