// This is the leader who waits for all connections and then sends the
// message to be signed
func GoLeader(conf *app.NaiveConfig) {
host := net.NewTcpHost(app.RunFlags.Hostname)
key := cliutils.KeyPair(suite)
leader := NewPeer(host, LeadRole, key.Secret, key.Public)
// Setting up the connections
// notably to the monitoring process
if app.RunFlags.Logger != "" {
monitor.ConnectSink(app.RunFlags.Logger)
} else {
monitor.EnableMeasure(false)
}
msg := []byte("Hello World\n")
// Listen for connections
dbg.Lvl3(leader.String(), "making connections ...")
// each conn will create its own channel to be used to handle rounds
roundChans := make(chan chan chan *net.BasicSignature)
// Send the message to be signed
proto := func(c net.Conn) {
// make the chan that will receive a new chan
// for each round where to send the signature
roundChan := make(chan chan *net.BasicSignature)
roundChans <- roundChan
n := 0
// wait for the next round
for sigChan := range roundChan {
dbg.Lvl3(leader.String(), "Round", n, "sending message", msg, "to signer", c.PeerName())
leader.SendMessage(msg, c)
dbg.Lvl3(leader.String(), "Round", n, "receivng signature from signer", c.PeerName())
sig := leader.ReceiveBasicSignature(c)
sigChan <- sig
n += 1
}
c.Close()
dbg.Lvl3(leader.String(), "closed connection with signer", c.PeerName())
}
// Connecting to the signer
setup := monitor.NewMeasure("setup")
go leader.Listen(app.RunFlags.Hostname, proto)
dbg.Lvl3(leader.String(), "Listening for channels creation..")
// listen for round chans + signatures for each round
masterRoundChan := make(chan chan *net.BasicSignature)
roundChanns := make([]chan chan *net.BasicSignature, 0)
numberHosts := len(conf.Hosts)
// Make the "setup" of channels
for {
ch := <-roundChans
roundChanns = append(roundChanns, ch)
//Received round channels from every connections-
if len(roundChanns) == numberHosts-1 {
// make the Fanout => master will send to all
go func() {
// send the new SignatureChannel to every conn
for newSigChan := range masterRoundChan {
for i, _ := range roundChanns {
go func(j int) { roundChanns[j] <- newSigChan }(i)
}
}
//close when finished
for _, c := range roundChanns {
close(c)
}
}()
break
}
}
setup.Measure()
dbg.Lvl3(leader.String(), "got all channels ready => starting the", conf.Rounds, "rounds")
// Starting to run the simulation for conf.Rounds rounds
roundM := monitor.NewMeasure("round")
for round := 0; round < conf.Rounds; round++ {
// Measure calculation time
calc := monitor.NewMeasure("calc")
dbg.Lvl1("Server starting round", round+1)
n := 0
faulty := 0
// launch a new round
connChan := make(chan *net.BasicSignature)
masterRoundChan <- connChan
// Wait each signatures
sigs := make([]*net.BasicSignature, 0)
for n < numberHosts-1 {
bs := <-connChan
sigs = append(sigs, bs)
n += 1
}
// All sigs reeived <=> all calcs are done
calc.Measure()
// verify each signatures
if conf.SkipChecks {
dbg.Lvl3("Skipping check for round", round)
} else {
// Measure verificationt time
verify := monitor.NewMeasure("verify")
for _, sig := range sigs {
if err := SchnorrVerify(suite, msg, *sig); err != nil {
faulty += 1
dbg.Lvl1(leader.String(), "Round", round, "received a faulty signature!")
} else {
dbg.Lvl3(leader.String(), "Round", round, "received Good signature")
}
}
verify.Measure()
}
roundM.Measure()
dbg.Lvl3(leader.String(), "Round", round, "received", len(conf.Hosts)-1, "signatures (",
faulty, "faulty sign)")
}
// Close down all connections
close(masterRoundChan)
dbg.Lvl3(leader.String(), "has done all rounds")
}
func RunRoot(conf *app.NTreeConfig) {
host := net.NewTcpHost(app.RunFlags.Hostname)
key := cliutils.KeyPair(suite)
peer := NewPeer(host, LeadRole, key.Secret, key.Public)
dbg.Lvl3(peer.String(), "Up and will make connections...")
// monitor
if app.RunFlags.Logger == "" {
monitor.EnableMeasure(false)
} else {
if err := monitor.ConnectSink(app.RunFlags.Logger); err != nil {
dbg.Fatal(peer.String(), "could not connect to the monitor:", err)
}
}
// msg to be sent + signed
msg := []byte("Hello World")
// make setup measurement
setup := monitor.NewMeasure("setup")
// masterRoundChan is used to tell that everyone is ready
masterRoundChan := make(chan chan chan *net.ListBasicSignature)
// Open connection for each children
for _, c := range conf.Tree.Children {
dbg.Lvl3(peer.String(), "will connect to children", c.Name)
connPeer := peer.Open(c.Name)
if connPeer == nil {
dbg.Fatal(peer.String(), "Could not open connection to child", c.Name)
}
// then start Root protocol
go func(conn net.Conn) {
dbg.Lvl3(peer.String(), "connected to children", conn.PeerName())
roundSigChan := make(chan chan *net.ListBasicSignature)
// notify we are ready to begin
masterRoundChan <- roundSigChan
// each rounds...
for lsigChan := range roundSigChan {
dbg.Lvl4(peer.String(), "starting new round with", conn.PeerName())
m := net.MessageSigning{
Length: len(msg),
Msg: msg,
}
// send msg to children
err := conn.Send(m)
if err != nil {
dbg.Fatal(peer.String(), "could not send message to children", conn.PeerName(), ":", err)
}
dbg.Lvl3(peer.String(), "sent message to children", conn.PeerName())
// Receive bundled signatures
sig, err := conn.Receive()
if err != nil {
dbg.Fatal(peer.String(), "could not received bundled signature from", conn.PeerName(), ":", err)
}
if sig.MsgType != net.ListBasicSignatureType {
dbg.Fatal(peer.String(), "received a wrong packet type from", conn.PeerName(), ":", sig.MsgType.String())
}
// Then pass them on
sigs := sig.Msg.(net.ListBasicSignature)
lsigChan <- &sigs
dbg.Lvl3(peer.String(), "Received list of signatures from child", conn.PeerName())
}
}(connPeer)
}
// First collect every "ready-connections"
children := make([]chan chan *net.ListBasicSignature, 0)
for round := range masterRoundChan {
children = append(children, round)
if len(children) == len(conf.Tree.Children) {
dbg.Lvl3(peer.String(), "collected each children channels")
break
}
}
close(masterRoundChan)
setup.Measure()
// Then for each rounds tell them to start the protocol
round := monitor.NewMeasure("round")
for i := 1; i <= conf.Rounds; i++ {
dbg.Lvl1(peer.String(), "will start a new round", i)
calc := monitor.NewMeasure("calc")
// the signature channel used for this round
lsigChan := make(chan *net.ListBasicSignature)
// notify each connections
for _, ch := range children {
ch <- lsigChan
}
childrenSigs := make([]*net.ListBasicSignature, 0)
// Wait for listsignatures coming
dbg.Lvl3(peer.String(), "Waiting on signatures for round", i, "...")
for sigs := range lsigChan {
dbg.Lvl3(peer.String(), "will analyze one ListBasicSignature...")
childrenSigs = append(childrenSigs, sigs)
// we have received all bundled signatures so time it
if len(childrenSigs) == len(conf.Tree.Children) {
close(lsigChan) // we have finished for this round
}
}
dbg.Lvl3(peer.String(), "Received all signatures ... ")
calc.Measure()
var verifyWg sync.WaitGroup
var faulty uint64 = 0
var total uint64 = 0
// start timing verification
verify := monitor.NewMeasure("verify")
for _, sigs := range childrenSigs {
// Here it launches one go routine to verify a bundle
verifyWg.Add(1)
go func(s *net.ListBasicSignature) {
defer verifyWg.Done()
if conf.SkipChecks {
return
}
// verify each independant signatures
for _, sig := range s.Sigs {
if err := SchnorrVerify(suite, msg, sig); err != nil {
dbg.Lvl2(peer.String(), "received incorrect signature ><", err)
atomic.AddUint64(&faulty, 1)
}
atomic.AddUint64(&total, 1)
}
}(sigs)
}
// wait for all verifications
verifyWg.Wait()
// finished verifying => time it !
verify.Measure()
round.Measure()
dbg.Lvl3(peer.String(), "Round", i, "/", conf.Rounds, "has verified all signatures:", total-faulty, "/", total, "good signatures")
}
// cLosing each channels
for _, ch := range children {
close(ch)
}
dbg.Lvl2(peer.String(), "Finished all rounds successfully.")
}