// Dispatch can handle timeouts func (p *Propagate) Dispatch() error { process := true log.Lvl4(p.ServerIdentity()) for process { p.Lock() timeout := time.Millisecond * time.Duration(p.sd.Msec) p.Unlock() select { case msg := <-p.ChannelSD: log.Lvl3(p.ServerIdentity(), "Got data from", msg.ServerIdentity, "and setting timeout to", msg.Msec) p.sd.Msec = msg.Msec if p.onData != nil { _, netMsg, err := network.UnmarshalRegistered(msg.Data) if err == nil { p.onData(netMsg) } } if !p.IsRoot() { log.Lvl3(p.ServerIdentity(), "Sending to parent") p.SendToParent(&PropagateReply{}) } if p.IsLeaf() { process = false } else { log.Lvl3(p.ServerIdentity(), "Sending to children") p.SendToChildren(&msg.PropagateSendData) } case <-p.ChannelReply: p.received++ log.Lvl4(p.ServerIdentity(), "received:", p.received, p.subtreeCount) if !p.IsRoot() { p.SendToParent(&PropagateReply{}) } if p.received == p.subtreeCount { process = false } case <-time.After(timeout): _, a, err := network.UnmarshalRegistered(p.sd.Data) log.Fatalf("Timeout of %s reached. %v %s", timeout, a, err) process = false } } if p.IsRoot() { if p.onDoneCb != nil { p.onDoneCb(p.received + 1) } } p.Done() return nil }
func TestProofCollective(t *testing.T) { suite := edwards.NewAES128SHA256Ed25519(false) // 1st set of base points g1, _ := suite.Point().Pick([]byte("G1"), random.Stream) h1, _ := suite.Point().Pick([]byte("H1"), random.Stream) // 1st secret value x := suite.Scalar().Pick(random.Stream) // 2nd set of base points g2, _ := suite.Point().Pick([]byte("G2"), random.Stream) h2, _ := suite.Point().Pick([]byte("H2"), random.Stream) // 2nd secret value y := suite.Scalar().Pick(random.Stream) // Create proof g := []abstract.Point{g1, g2} h := []abstract.Point{h1, h2} p, err := randhound.NewProof(suite, g, h, nil) log.ErrFatal(err) xG, xH, err := p.SetupCollective(x, y) log.ErrFatal(err) // Verify proof q, err := randhound.NewProof(suite, g, h, p.Core) log.ErrFatal(err) _, bad, err := q.Verify(xG, xH) log.ErrFatal(err) if len(bad) != 0 { log.Fatalf("Some proofs failed: %v", bad) } }
func TestPVSS(t *testing.T) { suite := edwards.NewAES128SHA256Ed25519(false) G := suite.Point().Base() H, _ := suite.Point().Pick(nil, suite.Cipher([]byte("H"))) n := 10 threshold := 2*n/3 + 1 x := make([]abstract.Scalar, n) // trustee private keys X := make([]abstract.Point, n) // trustee public keys index := make([]int, n) for i := 0; i < n; i++ { x[i] = suite.Scalar().Pick(random.Stream) X[i] = suite.Point().Mul(nil, x[i]) index[i] = i } // Scalar of shared secret secret := suite.Scalar().Pick(random.Stream) // (1) Share-Distribution (Dealer) pvss := randhound.NewPVSS(suite, H, threshold) idx, sX, encProof, pb, err := pvss.Split(X, secret) log.ErrFatal(err) // (2) Share-Decryption (Trustee) pbx := make([][]byte, n) for i := 0; i < n; i++ { pbx[i] = pb // NOTE: polynomials can be different } sH, err := pvss.Commits(pbx, index) log.ErrFatal(err) // Check that log_H(sH) == log_X(sX) using encProof _, bad, err := pvss.Verify(H, X, sH, sX, encProof) log.ErrFatal(err) if len(bad) != 0 { log.Fatalf("Some proofs failed: %v", bad) } // Decrypt shares S := make([]abstract.Point, n) decProof := make([]randhound.ProofCore, n) for i := 0; i < n; i++ { s, d, err := pvss.Reveal(x[i], sX[i:i+1]) log.ErrFatal(err) S[i] = s[0] decProof[i] = d[0] } // Check that log_G(S) == log_X(sX) using decProof _, bad, err = pvss.Verify(G, S, X, sX, decProof) log.ErrFatal(err) if len(bad) != 0 { log.Fatalf("Some proofs failed: %v", bad) } // (3) Secret-Recovery (Dealer) recovered, err := pvss.Recover(idx, S, len(S)) log.ErrFatal(err) // Verify recovered secret if !(suite.Point().Mul(nil, secret).Equal(recovered)) { log.Fatalf("Recovered incorrect shared secret") } }