func TestClient_CreateData(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(2, true)
defer l.CloseAll()
c := NewTestClient(l)
_, inter, cerr := c.CreateRootControl(el, el, 1, 1, 1, VerifyNone)
log.ErrFatal(cerr)
td := &testData{1, "data-sc"}
inter, data, cerr := c.CreateData(inter, 1, 1, VerifyNone, td)
log.ErrFatal(cerr)
if err := data.VerifySignatures(); err != nil {
t.Fatal("Couldn't verify data-signature:", err)
}
if !bytes.Equal(data.ParentBlockID, inter.Hash) {
t.Fatal("Data-chain doesn't point to intermediate-chain")
}
if !bytes.Equal(inter.ChildSL.Hash, data.Hash) {
t.Fatal("Intermediate chain doesn't point to data-chain")
}
_, td1, err := network.UnmarshalRegisteredType(data.Data, network.DefaultConstructors(network.Suite))
log.ErrFatal(err)
if *td != td1.(testData) {
t.Fatal("Stored data is not the same as initial data")
}
}
func TestIdentity_ConfigNewPropose(t *testing.T) {
l := onet.NewTCPTest()
hosts, el, _ := l.GenTree(2, true)
services := l.GetServices(hosts, identityService)
defer l.CloseAll()
c1 := NewTestIdentity(el, 50, "one", l)
log.ErrFatal(c1.CreateIdentity())
conf2 := c1.Config.Copy()
kp2 := config.NewKeyPair(network.Suite)
conf2.Device["two"] = &Device{kp2.Public}
log.ErrFatal(c1.ProposeSend(conf2))
for _, s := range services {
is := s.(*Service)
id1 := is.getIdentityStorage(c1.ID)
id1.Lock()
if id1 == nil {
t.Fatal("Didn't find")
}
assert.NotNil(t, id1.Proposed)
if len(id1.Proposed.Device) != 2 {
t.Fatal("The proposed config should have 2 entries now")
}
id1.Unlock()
}
}
func TestIdentity_SaveToStream(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
id := NewIdentity(el, 50, "one1")
tmpfile, err := ioutil.TempFile("", "example")
log.ErrFatal(err)
defer os.Remove(tmpfile.Name())
log.ErrFatal(id.SaveToStream(tmpfile))
tmpfile.Close()
tmpfile, err = os.Open(tmpfile.Name())
log.ErrFatal(err)
id2, err := NewIdentityFromStream(tmpfile)
assert.NotNil(t, id2)
log.ErrFatal(err)
tmpfile.Close()
if id.Config.Threshold != id2.Config.Threshold {
t.Fatal("Loaded threshold is not the same")
}
p, p2 := id.Config.Device["one1"].Point, id2.Config.Device["one1"].Point
if !p.Equal(p2) {
t.Fatal("Public keys are not the same")
}
if id.Config.Data["one1"] != id2.Config.Data["one1"] {
t.Fatal("Owners are not the same", id.Config.Data, id2.Config.Data)
}
}
func TestClient_GetUpdateChain(t *testing.T) {
if testing.Short() {
t.Skip("Long run not good for Travis")
}
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
clients := make(map[int]*Client)
for i := range [8]byte{} {
clients[i] = NewTestClient(l)
}
_, inter, cerr := clients[0].CreateRootControl(el, el, 1, 1, 1, VerifyNone)
log.ErrFatal(cerr)
wg := sync.WaitGroup{}
for i := range [128]byte{} {
wg.Add(1)
go func(i int) {
_, cerr := clients[i%8].GetUpdateChain(inter, inter.Hash)
log.ErrFatal(cerr)
wg.Done()
}(i)
}
wg.Wait()
}
func TestIdentity_ConfigNewCheck(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
c1 := NewIdentity(el, 50, "one")
log.ErrFatal(c1.CreateIdentity())
conf2 := c1.Config.Copy()
kp2 := config.NewKeyPair(network.Suite)
conf2.Device["two"] = &Device{kp2.Public}
conf2.Data["two"] = "public2"
log.ErrFatal(c1.ProposeSend(conf2))
log.ErrFatal(c1.ProposeUpdate())
al := c1.Proposed
assert.NotNil(t, al)
o2, ok := al.Device["two"]
assert.True(t, ok)
assert.True(t, kp2.Public.Equal(o2.Point))
pub2, ok := al.Data["two"]
assert.True(t, ok)
assert.Equal(t, "public2", pub2)
}
func TestClient_ProposeData(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
c := NewTestClient(l)
log.Lvl1("Creating root and control chain")
_, inter, cerr := c.CreateRootControl(el, el, 1, 1, 1, VerifyNone)
log.ErrFatal(cerr)
td := &testData{1, "data-sc"}
log.Lvl1("Creating data chain")
var data1 *SkipBlock
inter, data1, cerr = c.CreateData(inter, 1, 1, VerifyNone, td)
log.ErrFatal(cerr)
td.A++
log.Lvl1("Proposing data on intermediate chain")
data2, cerr := c.ProposeData(inter, data1, td)
log.ErrFatal(cerr)
dataLast, cerr := c.GetUpdateChain(inter, data1.Hash)
log.ErrFatal(cerr)
if len(dataLast.Update) != 2 {
t.Fatal("Should have two SkipBlocks for update-chain", len(dataLast.Update))
}
if !dataLast.Update[1].Equal(data2.Latest) {
t.Fatal("Newest SkipBlock should be stored")
}
c.Close()
}
func TestServiceStatus(t *testing.T) {
local := onet.NewTCPTest()
// generate 5 hosts, they don't connect, they process messages, and they
// don't register the tree or entitylist
_, el, tr := local.GenTree(5, false)
defer local.CloseAll()
// Send a request to the service
client := NewTestClient(local)
log.Lvl1("Sending request to service...")
stat, cerr := client.Request(el.List[0])
log.Lvl1(el.List[0])
log.ErrFatal(cerr)
log.Lvl1(stat)
assert.NotEmpty(t, stat.Msg["Status"].Field["Available_Services"])
pi, err := local.CreateProtocol("ExampleChannels", tr)
if err != nil {
t.Fatal("Couldn't start protocol:", err)
}
go pi.Start()
<-pi.(*channels.ProtocolExampleChannels).ChildCount
stat, cerr = client.Request(el.List[0])
log.ErrFatal(cerr)
log.Lvl1(stat)
assert.NotEmpty(t, stat.Msg["Status"].Field["Available_Services"])
}
func TestIdentity_CreateIdentity(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(3, true)
defer l.CloseAll()
c := NewTestIdentity(el, 50, "one", l)
log.ErrFatal(c.CreateIdentity())
// Check we're in the configuration
assert.NotNil(t, c.Config)
}
func TestService_CreateIdentity2(t *testing.T) {
local := onet.NewTCPTest()
defer local.CloseAll()
_, el, s := local.MakeHELS(5, identityService)
service := s.(*Service)
keypair := config.NewKeyPair(network.Suite)
il := NewConfig(50, keypair.Public, "one")
msg, cerr := service.CreateIdentity(&CreateIdentity{il, el})
log.ErrFatal(cerr)
air := msg.(*CreateIdentityReply)
data := air.Data
id, ok := service.Identities[string(data.Hash)]
assert.True(t, ok)
assert.NotNil(t, id)
}
func TestIdentity_ConfigUpdate(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
c1 := NewTestIdentity(el, 50, "one", l)
log.ErrFatal(c1.CreateIdentity())
c2 := NewTestIdentity(el, 50, "two", l)
c2.ID = c1.ID
log.ErrFatal(c2.ConfigUpdate())
assert.NotNil(t, c2.Config)
o1 := c2.Config.Device[c1.DeviceName]
if !o1.Point.Equal(c1.Public) {
t.Fatal("Owner is not c1")
}
}
func TestServiceGuard(t *testing.T) {
local := onet.NewTCPTest()
_, el, _ := local.GenTree(5, true)
defer local.CloseAll()
// Send a request to the service
client := NewLocalTestClient(local)
log.Lvl1("Sending request to service...")
UID := []byte("USER")
Epoch := []byte("EPOCH")
msg := network.Suite.Point()
Hzi, _ := client.SendToGuard(el.List[0], UID, Epoch, msg)
// We send the message twice to see that the key did not change for the
//same epoch.
Hz2, _ := client.SendToGuard(el.List[0], UID, Epoch, msg)
assert.Equal(t, Hzi, Hz2)
}
func TestServiceCosi(t *testing.T) {
defer log.AfterTest(t)
log.TestOutput(testing.Verbose(), 4)
local := onet.NewTCPTest()
// generate 5 hosts, they don't connect, they process messages, and they
// don't register the tree or entitylist
hosts, el, _ := local.GenTree(5, false)
defer local.CloseAll()
// Send a request to the service
client := NewTestClient(local)
msg := []byte("hello cosi service")
log.Lvl1("Sending request to service...")
res, err := client.SignatureRequest(el, msg)
log.ErrFatal(err, "Couldn't send")
// verify the response still
assert.Nil(t, cosi.VerifySignature(hosts[0].Suite(), el.Publics(),
msg, res.Signature))
}
func TestClient_ProposeRoster(t *testing.T) {
t.Skip("See https://github.com/dedis/cothority/issues/733")
nbrHosts := 5
l := onet.NewTCPTest()
_, el, _ := l.GenTree(nbrHosts, true)
defer l.CloseAll()
c := NewTestClient(l)
log.Lvl1("Creating root and control chain")
_, inter, cerr := c.CreateRootControl(el, el, 1, 1, 1, VerifyNone)
log.ErrFatal(cerr)
el2 := onet.NewRoster(el.List[:nbrHosts-1])
log.Lvl1("Proposing roster", el2)
var sb1 *ProposedSkipBlockReply
sb1, cerr = c.ProposeRoster(inter, el2)
log.ErrFatal(cerr)
log.Lvl1("Proposing same roster again")
_, cerr = c.ProposeRoster(inter, el2)
if cerr == nil {
t.Fatal("Appending two Blocks to the same last block should fail")
}
log.Lvl1("Proposing following roster")
sb2, cerr := c.ProposeRoster(sb1.Latest, el2)
log.ErrFatal(cerr)
if !sb2.Previous.Equal(sb1.Latest) {
t.Fatal("New previous should be previous latest")
}
if !bytes.Equal(sb2.Previous.ForwardLink[0].Hash,
sb2.Latest.Hash) {
t.Fatal("second should point to third SkipBlock")
}
updates, cerr := c.GetUpdateChain(inter, inter.Hash)
if len(updates.Update) != 3 {
t.Fatal("Should now have three Blocks to go from Genesis to current, but have", len(updates.Update), inter, sb2)
}
if !updates.Update[2].Equal(sb2.Latest) {
t.Fatal("Last block in update-chain should be last block added")
}
c.Close()
}
func TestCrashAfterRevocation(t *testing.T) {
l := onet.NewTCPTest()
hosts, el, _ := l.GenTree(5, true)
services := l.GetServices(hosts, identityService)
defer l.CloseAll()
for _, s := range services {
log.Lvl3(s.(*Service).Identities)
}
c1 := NewIdentity(el, 2, "one")
c2 := NewIdentity(el, 2, "two")
c3 := NewIdentity(el, 2, "three")
defer c1.Close()
defer c2.Close()
defer c3.Close()
log.ErrFatal(c1.CreateIdentity())
log.ErrFatal(c2.AttachToIdentity(c1.ID))
proposeUpVote(c1)
log.ErrFatal(c3.AttachToIdentity(c1.ID))
proposeUpVote(c1)
proposeUpVote(c2)
log.ErrFatal(c1.ConfigUpdate())
log.Lvl2(c1.Config)
conf := c1.GetProposed()
delete(conf.Device, "three")
log.Lvl2(conf)
log.ErrFatal(c1.ProposeSend(conf))
proposeUpVote(c1)
proposeUpVote(c2)
log.ErrFatal(c1.ConfigUpdate())
log.Lvl2(c1.Config)
log.Lvl1("C3 trying to send anyway")
conf = c3.GetProposed()
c3.ProposeSend(conf)
if c3.ProposeVote(true) == nil {
t.Fatal("Should not be able to vote")
}
log.ErrFatal(c1.ProposeUpdate())
}
func TestIdentity_AttachToIdentity(t *testing.T) {
l := onet.NewTCPTest()
hosts, el, _ := l.GenTree(5, true)
services := l.GetServices(hosts, identityService)
for _, s := range services {
s.(*Service).clearIdentities()
}
defer l.CloseAll()
c1 := NewTestIdentity(el, 50, "one", l)
log.ErrFatal(c1.CreateIdentity())
c2 := NewTestIdentity(el, 50, "two", l)
log.ErrFatal(c2.AttachToIdentity(c1.ID))
for _, s := range services {
is := s.(*Service)
is.identitiesMutex.Lock()
if len(is.Identities) != 1 {
t.Fatal("The configuration hasn't been proposed in all services")
}
is.identitiesMutex.Unlock()
}
}
func TestClient_CreateRootInter(t *testing.T) {
l := onet.NewTCPTest()
_, el, _ := l.GenTree(5, true)
defer l.CloseAll()
c := NewTestClient(l)
root, inter, cerr := c.CreateRootControl(el, el, 1, 1, 1, VerifyNone)
log.ErrFatal(cerr)
if root == nil || inter == nil {
t.Fatal("Pointers are nil")
}
if err := root.VerifySignatures(); err != nil {
t.Fatal("Root signature invalid:", err)
}
if err := inter.VerifySignatures(); err != nil {
t.Fatal("Root signature invalid:", err)
}
if !bytes.Equal(root.ChildSL.Hash, inter.Hash) {
t.Fatal("Root doesn't point to intermediate")
}
if !bytes.Equal(inter.ParentBlockID, root.Hash) {
t.Fatal("Intermediate doesn't point to root")
}
}
func TestIdentity_ProposeVote(t *testing.T) {
l := onet.NewTCPTest()
hosts, el, _ := l.GenTree(5, true)
services := l.GetServices(hosts, identityService)
defer l.CloseAll()
for _, s := range services {
log.Lvl3(s.(*Service).Identities)
}
c1 := NewTestIdentity(el, 50, "one1", l)
log.ErrFatal(c1.CreateIdentity())
conf2 := c1.Config.Copy()
kp2 := config.NewKeyPair(network.Suite)
conf2.Device["two2"] = &Device{kp2.Public}
conf2.Data["two2"] = "public2"
log.ErrFatal(c1.ProposeSend(conf2))
log.ErrFatal(c1.ProposeUpdate())
log.ErrFatal(c1.ProposeVote(true))
if len(c1.Config.Device) != 2 {
t.Fatal("Should have two owners now")
}
}