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 TestService_MultiLevel(t *testing.T) {
local := onet.NewLocalTest()
defer local.CloseAll()
_, el, genService := local.MakeHELS(3, skipchainSID)
service := genService.(*Service)
for base := 1; base <= 3; base++ {
for height := 1; height <= 3; height++ {
if base == 1 && height > 1 {
break
}
sbRoot, err := makeGenesisRosterArgs(service, el, nil, VerifyNone,
base, height)
log.ErrFatal(err)
latest := sbRoot
log.Lvl1("Adding blocks for", base, height)
for sbi := 1; sbi < 10; sbi++ {
sb := NewSkipBlock()
sb.Roster = el
psbr, err := service.ProposeSkipBlock(&ProposeSkipBlock{latest.Hash, sb})
log.ErrFatal(err)
latest = psbr.(*ProposedSkipBlockReply).Latest
}
log.ErrFatal(checkMLForwardBackward(service, sbRoot, base, height))
log.ErrFatal(checkMLUpdate(service, sbRoot, latest, base, height))
}
}
// Setting up two chains and linking one to the other
}
func followAdd(c *cli.Context) error {
if c.NArg() < 2 {
log.Fatal("Please give a group-definition, an ID, and optionally a service-name of the skipchain to follow")
}
cfg, _ := loadConfig(c)
group := getGroup(c)
idBytes, err := hex.DecodeString(c.Args().Get(1))
log.ErrFatal(err)
id := identity.ID(idBytes)
newID, err := identity.NewIdentityFromCothority(group.Roster, id)
log.ErrFatal(err)
if c.NArg() == 3 {
newID.DeviceName = c.Args().Get(2)
} else {
var err error
newID.DeviceName, err = os.Hostname()
log.ErrFatal(err)
log.Info("Using", newID.DeviceName, "as the device-name.")
}
cfg.Follow = append(cfg.Follow, newID)
cfg.writeAuthorizedKeys(c)
// Identity needs to exist, else saving/loading will fail. For
// followers it doesn't matter if the identity will be overwritten,
// as it is not used.
cfg.Identity = newID
return cfg.saveConfig(c)
}
func TestService_Verification(t *testing.T) {
local := onet.NewLocalTest()
defer local.CloseAll()
sbLength := 4
_, el, genService := local.MakeHELS(sbLength, skipchainSID)
service := genService.(*Service)
elRoot := onet.NewRoster(el.List[0:3])
sbRoot, err := makeGenesisRoster(service, elRoot)
log.ErrFatal(err)
log.Lvl1("Creating non-conforming skipBlock")
sb := NewSkipBlock()
sb.Roster = el
sb.MaximumHeight = 1
sb.BaseHeight = 1
sb.ParentBlockID = sbRoot.Hash
sb.VerifierID = VerifyShard
_, err = service.ProposeSkipBlock(&ProposeSkipBlock{nil, sb})
require.NotNil(t, err, "Shouldn't accept a non-confoirming skipblock")
log.Lvl1("Creating skipblock with same Roster as root")
sbInter, err := makeGenesisRosterArgs(service, elRoot, sbRoot.Hash, VerifyShard, 1, 1)
log.ErrFatal(err)
log.Lvl1("Creating skipblock with sub-Roster from root")
elSub := onet.NewRoster(el.List[0:2])
sbInter, err = makeGenesisRosterArgs(service, elSub, sbRoot.Hash, VerifyShard, 1, 1)
log.ErrFatal(err)
scsb := &SetChildrenSkipBlock{sbRoot.Hash, sbInter.Hash}
service.SetChildrenSkipBlock(scsb)
}
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 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 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 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 newSkipchainService(c *onet.Context, path string) onet.Service {
s := &Service{
ServiceProcessor: onet.NewServiceProcessor(c),
path: path,
SkipBlockMap: &SkipBlockMap{make(map[string]*SkipBlock)},
verifiers: map[VerifierID]SkipBlockVerifier{},
}
var err error
s.Propagate, err = manage.NewPropagationFunc(c, "SkipchainPropagate", s.PropagateSkipBlock)
log.ErrFatal(err)
c.ProtocolRegister(skipchainBFT, func(n *onet.TreeNodeInstance) (onet.ProtocolInstance, error) {
return bftcosi.NewBFTCoSiProtocol(n, s.bftVerify)
})
if err := s.tryLoad(); err != nil {
log.Error(err)
}
log.ErrFatal(s.RegisterHandlers(s.ProposeSkipBlock, s.SetChildrenSkipBlock,
s.GetUpdateChain))
if err := s.RegisterVerification(VerifyShard, s.VerifyShardFunc); err != nil {
log.Panic(err)
}
if err := s.RegisterVerification(VerifyNone, s.VerifyNoneFunc); err != nil {
log.Panic(err)
}
return s
}
// signFile will search for the file and sign it
// it always returns nil as an error
func signFile(c *cli.Context) error {
if c.Args().First() == "" {
log.Fatal("Please give the file to sign", 1)
}
fileName := c.Args().First()
groupToml := c.String(optionGroup)
file, err := os.Open(fileName)
log.ErrFatal(err, "Couldn't read file to be signed:")
sig, err := sign(file, groupToml)
log.ErrFatal(err, "Couldn't create signature:")
log.Lvl3(sig)
var outFile *os.File
outFileName := c.String("out")
if outFileName != "" {
outFile, err = os.Create(outFileName)
log.ErrFatal(err, "Couldn't create signature file:")
} else {
outFile = os.Stdout
}
writeSigAsJSON(sig, outFile)
if outFileName != "" {
log.Lvl2("Signature written to: %s", outFile.Name())
} // else keep the Stdout empty
return nil
}
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 TestService_RegisterVerification(t *testing.T) {
// Testing whether we sign correctly the SkipBlocks
onet.RegisterNewService("ServiceVerify", newServiceVerify)
local := onet.NewLocalTest()
defer local.CloseAll()
hosts, el, s1 := makeHELS(local, 3)
VerifyTest := VerifierID(uuid.NewV5(uuid.NamespaceURL, "Test1"))
ver := make(chan bool, 3)
verifier := func(msg []byte, s *SkipBlock) bool {
ver <- true
return true
}
for _, h := range hosts {
s := h.GetService(ServiceName).(*Service)
log.ErrFatal(s.RegisterVerification(VerifyTest, verifier))
}
sb, err := makeGenesisRosterArgs(s1, el, nil, VerifyTest, 1, 1)
log.ErrFatal(err)
require.NotNil(t, sb.Data)
require.Equal(t, 3, len(ver))
sb, err = makeGenesisRosterArgs(s1, el, nil, ServiceVerifier, 1, 1)
log.ErrFatal(err)
require.NotNil(t, sb.Data)
require.Equal(t, 3, len(ServiceVerifierChan))
}
// loadConfig will try to load the configuration and `fatal` if it is there but
// not valid. If the config-file is missing altogether, loaded will be false and
// an empty config-file will be returned.
func loadConfig(c *cli.Context) (cfg *ciscConfig, loaded bool) {
cfg = &ciscConfig{Identity: &identity.Identity{}}
loaded = true
configFile := getConfig(c)
log.Lvl2("Loading from", configFile)
buf, err := ioutil.ReadFile(configFile)
if err != nil {
if os.IsNotExist(err) {
return
}
log.ErrFatal(err)
}
_, msg, err := network.UnmarshalRegistered(buf)
log.ErrFatal(err)
cfg, loaded = msg.(*ciscConfig)
cfg.Identity.Client = onet.NewClient(identity.ServiceName)
for _, f := range cfg.Follow {
f.Client = onet.NewClient(identity.ServiceName)
}
if !loaded {
log.Fatal("Wrong message-type in config-file")
}
return
}
func TestService_SetChildrenSkipBlock(t *testing.T) {
// How many nodes in Root
nodesRoot := 3
local := onet.NewLocalTest()
defer local.CloseAll()
hosts, el, genService := local.MakeHELS(nodesRoot, skipchainSID)
service := genService.(*Service)
// Setting up two chains and linking one to the other
sbRoot, err := makeGenesisRoster(service, el)
log.ErrFatal(err)
sbInter, err := makeGenesisRosterArgs(service, el, sbRoot.Hash, VerifyNone, 1, 1)
log.ErrFatal(err)
scsb := &SetChildrenSkipBlock{sbRoot.Hash, sbInter.Hash}
service.SetChildrenSkipBlock(scsb)
// Verifying other nodes also got the updated chains
// Check for the root-chain
for i, h := range hosts {
log.Lvlf2("%x", skipchainSID)
s := local.Services[h.ServerIdentity.ID][skipchainSID].(*Service)
m, err := s.GetUpdateChain(&GetUpdateChain{sbRoot.Hash})
log.ErrFatal(err, "Failed in iteration="+strconv.Itoa(i)+":")
sb := m.(*GetUpdateChainReply)
log.Lvl2(s.Context)
if len(sb.Update) != 1 {
// we expect only the first block
t.Fatal("There should be only 1 SkipBlock in the update")
}
link := sb.Update[0].ChildSL
if !bytes.Equal(link.Hash, sbInter.Hash) {
t.Fatal("The child-link doesn't point to our intermediate SkipBlock", i)
}
// We need to verify the signature on the child-link, too. This
// has to be signed by the collective signature of sbRoot.
if cerr := sbRoot.VerifySignatures(); cerr != nil {
t.Fatal("Signature on child-link is not valid")
}
}
// And check for the intermediate-chain to be updated
for _, h := range hosts {
s := local.Services[h.ServerIdentity.ID][skipchainSID].(*Service)
m, cerr := s.GetUpdateChain(&GetUpdateChain{sbInter.Hash})
sb := m.(*GetUpdateChainReply)
log.ErrFatal(cerr)
if len(sb.Update) != 1 {
t.Fatal("There should be only 1 SkipBlock in the update")
}
if !bytes.Equal(sb.Update[0].ParentBlockID, sbRoot.Hash) {
t.Fatal("The intermediate SkipBlock doesn't point to the root")
}
if err := sb.Update[0].VerifySignatures(); err != nil {
t.Fatal("Signature of that SkipBlock doesn't fit")
}
}
}
func TestService_GetUpdateChain(t *testing.T) {
// Create a small chain and test whether we can get from one element
// of the chain to the last element with a valid slice of SkipBlocks
local := onet.NewLocalTest()
defer local.CloseAll()
sbLength := 3
_, el, gs := local.MakeHELS(sbLength, skipchainSID)
s := gs.(*Service)
sbs := make([]*SkipBlock, sbLength)
var err error
sbs[0], err = makeGenesisRoster(s, el)
log.ErrFatal(err)
log.Lvl1("Initialize skipchain.")
// init skipchain
for i := 1; i < sbLength; i++ {
log.Lvl2("Doing skipblock", i)
newSB := NewSkipBlock()
newSB.Roster = el
psbrMsg, err := s.ProposeSkipBlock(&ProposeSkipBlock{sbs[i-1].Hash, newSB})
assert.Nil(t, err)
reply := psbrMsg.(*ProposedSkipBlockReply)
sbs[i] = reply.Latest
}
for i := 0; i < sbLength; i++ {
m, err := s.GetUpdateChain(&GetUpdateChain{sbs[i].Hash})
sbc := m.(*GetUpdateChainReply)
log.ErrFatal(err)
if !sbc.Update[0].Equal(sbs[i]) {
t.Fatal("First hash is not from our SkipBlock")
}
if !sbc.Update[len(sbc.Update)-1].Equal(sbs[sbLength-1]) {
log.Lvl2(sbc.Update[len(sbc.Update)-1].Hash)
log.Lvl2(sbs[sbLength-1].Hash)
t.Fatal("Last Hash is not equal to last SkipBlock for", i)
}
for up, sb1 := range sbc.Update {
log.ErrFatal(sb1.VerifySignatures())
if up < len(sbc.Update)-1 {
sb2 := sbc.Update[up+1]
h1 := sb1.Height
h2 := sb2.Height
log.Lvl2("sbc1.Height=", sb1.Height)
log.Lvl2("sbc2.Height=", sb2.Height)
// height := min(len(sb1.ForwardLink), h2)
height := h1
if h2 < height {
height = h2
}
if !bytes.Equal(sb1.ForwardLink[height-1].Hash,
sb2.Hash) {
t.Fatal("Forward-pointer of", up,
"is different of hash in", up+1)
}
}
}
}
}
// loadConfigOrFail tries to load the config and fails if it doesn't succeed.
// If a configuration has been loaded, it will update the config and propose
// part of the identity.
func loadConfigOrFail(c *cli.Context) *ciscConfig {
cfg, loaded := loadConfig(c)
if !loaded {
log.Fatal("Couldn't load configuration-file")
}
log.ErrFatal(cfg.ConfigUpdate())
log.ErrFatal(cfg.ProposeUpdate())
return cfg
}
func main() {
network.RegisterPacketType(&Database{})
app := cli.NewApp()
app.Name = "Guard"
app.Usage = "Get and print status of all servers of a file."
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "group, gd",
Value: "group.toml",
Usage: "Cothority group definition in `FILE.toml`",
},
cli.IntFlag{
Name: "debug, d",
Value: 0,
Usage: "debug-level: `integer`: 1 for terse, 5 for maximal",
},
}
app.Commands = []cli.Command{
{
Name: "setpass",
Aliases: []string{"s"},
Usage: "Setup the configuration for the server (interactive)",
Action: setpass,
},
{
Name: "setup",
Aliases: []string{"su"},
Usage: "Saves the cothority group-toml to the configuration",
ArgsUsage: "Give group definition",
Action: setup,
},
{
Name: "recover",
Aliases: []string{"r"},
Usage: "Gets the password back from the guards",
Action: get,
},
}
app.Before = func(c *cli.Context) error {
b, err := ioutil.ReadFile("config.bin")
if os.IsNotExist(err) {
return nil
}
log.ErrFatal(err, "The config.bin file threw an error")
_, msg, err := network.UnmarshalRegistered(b)
log.ErrFatal(err, "UnmarshalRegistered messeed up")
var ok bool
db, ok = msg.(*Database)
if !ok {
log.Fatal("The message was improperly converted")
}
return nil
}
app.Run(os.Args)
}
// Reads the group-file and returns it
func getGroup(c *cli.Context) *config.Group {
gfile := c.Args().Get(0)
gr, err := os.Open(gfile)
log.ErrFatal(err)
defer gr.Close()
groups, err := config.ReadGroupDescToml(gr)
log.ErrFatal(err)
if groups == nil || groups.Roster == nil || len(groups.Roster.List) == 0 {
log.Fatal("No servers found in roster from", gfile)
}
return groups
}
// Config contacts all servers and verifies if it receives a valid
// signature from each.
// If the roster is empty it will return an error.
// If a server doesn't reply in time, it will return an error.
func Config(tomlFileName string) error {
f, err := os.Open(tomlFileName)
log.ErrFatal(err, "Couldn't open group definition file")
group, err := config.ReadGroupDescToml(f)
log.ErrFatal(err, "Error while reading group definition file", err)
if len(group.Roster.List) == 0 {
log.ErrFatalf(err, "Empty entity or invalid group defintion in: %s",
tomlFileName)
}
log.Info("Checking the availability and responsiveness of the servers in the group...")
return Servers(group)
}
// writeSigAsJSON - writes the JSON out to a file
func writeSigAsJSON(res *s.SignatureResponse, outW io.Writer) {
b, err := json.Marshal(res)
log.ErrFatal(err, "Couldn't encode signature:")
var out bytes.Buffer
json.Indent(&out, b, "", "\t")
outW.Write([]byte("\n"))
_, err = out.WriteTo(outW)
log.ErrFatal(err, "Couldn't write signature:")
outW.Write([]byte("\n"))
}
/*
* Commands related to the config in general
*/
func configUpdate(c *cli.Context) error {
cfg := loadConfigOrFail(c)
log.ErrFatal(cfg.ConfigUpdate())
log.ErrFatal(cfg.ProposeUpdate())
log.Info("Successfully updated")
log.ErrFatal(cfg.saveConfig(c))
if cfg.Proposed != nil {
cfg.showDifference()
} else {
cfg.showKeys()
}
return nil
}
// setup is called when you setup the password database.
func setup(c *cli.Context) error {
groupToml := c.Args().First()
var err error
t, err := readGroup(groupToml)
db = &Database{
Cothority: t,
}
log.ErrFatal(err)
b, err := network.MarshalRegisteredType(db)
log.ErrFatal(err)
err = ioutil.WriteFile("config.bin", b, 0660)
log.ErrFatal(err)
return nil
}
func runProtocolOnceGo(nbrHosts int, name string, refuseCount int,
succeed bool) error {
log.Lvl2("Running BFTCoSi with", nbrHosts, "hosts")
local := onet.NewLocalTest()
defer local.CloseAll()
_, _, tree := local.GenBigTree(nbrHosts, nbrHosts, 2, true)
log.Lvl3("Tree is:", tree.Dump())
done := make(chan bool)
// create the message we want to sign for this round
msg := []byte("Hello BFTCoSi")
// Start the protocol
node, err := local.CreateProtocol(name, tree)
if err != nil {
return errors.New("Couldn't create new node: " + err.Error())
}
// Register the function generating the protocol instance
var root *ProtocolBFTCoSi
root = node.(*ProtocolBFTCoSi)
root.Msg = msg
cMux.Lock()
counter := &Counter{refuseCount: refuseCount}
counters.add(counter)
root.Data = []byte(strconv.Itoa(counters.size() - 1))
log.Lvl3("Added counter", counters.size()-1, refuseCount)
cMux.Unlock()
log.ErrFatal(err)
// function that will be called when protocol is finished by the root
root.RegisterOnDone(func() {
done <- true
})
go node.Start()
log.Lvl1("Launched protocol")
// are we done yet?
wait := time.Second * 60
select {
case <-done:
counter.Lock()
if counter.veriCount != nbrHosts {
return errors.New("Each host should have called verification.")
}
// if assert refuses we don't care for unlocking (t.Refuse)
counter.Unlock()
sig := root.Signature()
err := sig.Verify(root.Suite(), root.Roster().Publics())
if succeed && err != nil {
return fmt.Errorf("%s Verification of the signature refused: %s - %+v", root.Name(), err.Error(), sig.Sig)
}
if !succeed && err == nil {
return fmt.Errorf("%s: Shouldn't have succeeded for %d hosts, but signed for count: %d",
root.Name(), nbrHosts, refuseCount)
}
case <-time.After(wait):
log.Lvl1("Going to break because of timeout")
return errors.New("Waited " + wait.String() + " for BFTCoSi to finish ...")
}
return nil
}
func TestThreshold(t *testing.T) {
const TestProtocolName = "DummyBFTCoSiThr"
// Register test protocol using BFTCoSi
onet.GlobalProtocolRegister(TestProtocolName, func(n *onet.TreeNodeInstance) (onet.ProtocolInstance, error) {
return NewBFTCoSiProtocol(n, verify)
})
local := onet.NewLocalTest()
defer local.CloseAll()
tests := []struct{ h, t int }{
{1, 1},
{2, 2},
{3, 2},
{4, 3},
{5, 4},
{6, 4},
}
for _, s := range tests {
hosts, thr := s.h, s.t
log.Lvl3("Hosts is", hosts)
_, _, tree := local.GenBigTree(hosts, hosts, 2, true)
log.Lvl3("Tree is:", tree.Dump())
// Start the protocol
node, err := local.CreateProtocol(TestProtocolName, tree)
log.ErrFatal(err)
bc := node.(*ProtocolBFTCoSi)
assert.Equal(t, thr, bc.threshold, "hosts was %d", hosts)
local.CloseAll()
}
}
func followUpdate(c *cli.Context) error {
cfg := loadConfigOrFail(c)
for _, f := range cfg.Follow {
log.ErrFatal(f.ConfigUpdate())
}
cfg.writeAuthorizedKeys(c)
return cfg.saveConfig(c)
}
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 TestService_ProposeSkipBlock(t *testing.T) {
// First create a roster to attach the data to it
local := onet.NewLocalTest()
defer local.CloseAll()
_, el, genService := local.MakeHELS(5, skipchainSID)
service := genService.(*Service)
service.SkipBlocks = make(map[string]*SkipBlock)
// Setting up root roster
sbRoot, err := makeGenesisRoster(service, el)
log.ErrFatal(err)
// send a ProposeBlock
genesis := NewSkipBlock()
genesis.Data = []byte("In the beginning God created the heaven and the earth.")
genesis.MaximumHeight = 2
genesis.BaseHeight = 2
genesis.ParentBlockID = sbRoot.Hash
genesis.Roster = sbRoot.Roster
blockCount := 0
psbrMsg, err := service.ProposeSkipBlock(&ProposeSkipBlock{nil, genesis})
assert.Nil(t, err)
psbr := psbrMsg.(*ProposedSkipBlockReply)
latest := psbr.Latest
// verify creation of GenesisBlock:
assert.Equal(t, blockCount, latest.Index)
// the genesis block has a random back-link:
assert.Equal(t, 1, len(latest.BackLinkIds))
assert.NotEqual(t, 0, latest.BackLinkIds)
next := NewSkipBlock()
next.Data = []byte("And the earth was without form, and void; " +
"and darkness was upon the face of the deep. " +
"And the Spirit of God moved upon the face of the waters.")
next.MaximumHeight = 2
next.ParentBlockID = sbRoot.Hash
next.Roster = sbRoot.Roster
id := psbr.Latest.Hash
psbrMsg, err = service.ProposeSkipBlock(&ProposeSkipBlock{id, next})
assert.Nil(t, err)
psbr2 := psbrMsg.(*ProposedSkipBlockReply)
log.Lvl2(psbr2)
if psbr2 == nil {
t.Fatal("Didn't get anything in return")
}
assert.NotNil(t, psbr2)
assert.NotNil(t, psbr2.Latest)
latest2 := psbr2.Latest
// verify creation of GenesisBlock:
blockCount++
assert.Equal(t, blockCount, latest2.Index)
assert.Equal(t, 1, len(latest2.BackLinkIds))
assert.NotEqual(t, 0, latest2.BackLinkIds)
// We've added 2 blocks, + root block = 3
assert.Equal(t, 3, service.lenSkipBlocks())
}
// newGuardService creates a new service that is built for Guard.
func newGuardService(c *onet.Context, path string) onet.Service {
s := &Guard{
ServiceProcessor: onet.NewServiceProcessor(c),
path: path,
}
err := s.RegisterHandler(s.Request)
if err != nil {
log.ErrFatal(err, "Couldn't register message:")
}
//This is the area where Z is generated for a server
const n = 88
lel := make([]byte, n)
_, err = rand.Read(lel)
log.ErrFatal(err)
s.Z = lel
return s
}
func setpass(c *cli.Context) error {
uid := []byte(c.Args().Get(0))
Pass := c.Args().Get(1)
usrdata := []byte(c.Args().Get(2))
set(c, uid, []byte(EPOCH), string(Pass), usrdata)
b, err := network.MarshalRegisteredType(db)
log.ErrFatal(err)
err = ioutil.WriteFile("config.bin", b, 0660)
return nil
}
