nd: better public interface

Author: torch

nd/nd.go

@@ -57,12 +57,9 @@ func (nd *NetDog) Close() error {
 	return nd.dirConn.Close()
 }
 
-func (nd *NetDog) pick(needle *[32]byte) *directory.ShortNodeInfo {
+func Pick(routers []*directory.ShortNodeInfo, needle *[32]byte) *directory.ShortNodeInfo {
 	var highestNotGreater *directory.ShortNodeInfo
-	for _, ni := range nd.routers {
-		if !ni.Fast || !ni.Stable || !ni.Running || !ni.Valid {
-			continue
-		}
+	for _, ni := range routers {
 		if bytes.Compare(ni.ID[:], needle[:]) <= 0 &&
 			(highestNotGreater == nil || bytes.Compare(ni.ID[:], highestNotGreater.ID[:]) > 0) {
 			highestNotGreater = ni
@@ -71,11 +68,8 @@ func (nd *NetDog) pick(needle *[32]byte) *directory.ShortNodeInfo {
 	if highestNotGreater != nil {
 		return highestNotGreater
 	}
-	highestOverall := nd.routers[0]
-	for _, ni := range nd.routers {
-		if !ni.Fast || !ni.Stable || !ni.Running {
-			continue
-		}
+	highestOverall := routers[0]
+	for _, ni := range routers {
 		if bytes.Compare(ni.ID[:], highestOverall.ID[:]) > 0 {
 			highestOverall = ni
 		}
@@ -85,45 +79,25 @@ func (nd *NetDog) pick(needle *[32]byte) *directory.ShortNodeInfo {
 
 // connect requires len(cookie) = 20 and len(sendPayload) == 148. Nondeterminisitcally, EITHER
 // the sendPayload is sent to the peer OR their sendPayload is returned here, not both.
-func connect(ctx context.Context, tc *torch.TorConn, cookie []byte, sendPayload []byte, tcID []byte, tcNtorPublic []byte) (*torch.TorConn, *torch.Circuit, []byte, error) {
-	type circRet struct {
-		*torch.Circuit
-		error
-	}
-	ch := make(chan circRet)
-	mkCirc := func() {
-		circ, err := tc.CreateCircuit(ctx, tcID, tcNtorPublic)
-		ch <- circRet{circ, err}
-	}
-	go mkCirc()
-	go mkCirc()
-
-	cr := <-ch
-	if cr.error != nil {
-		<-ch
-		return nil, nil, nil, cr.error
-	}
-	circ := cr.Circuit
-	accept, err := circ.ListenRendezvousRaw(cookie)
-	if err == nil {
+func connect(ctx context.Context, c1, c2 *torch.Circuit, cookie []byte, sendPayload []byte) (*torch.Circuit, []byte, error) {
+	if accept, err := c1.ListenRendezvousRaw(cookie); err == nil {
+		c2.Close()
+
 		recvPayload, err := accept()
 		if err != nil {
-			return nil, nil, nil, err
+			c1.Close()
+			return nil, nil, err
 		}
-		go func() { <-ch; close(ch) }()
-		return tc, circ, recvPayload, nil
-	}
-	cr = <-ch
-	close(ch)
-	if cr.error != nil {
-		<-ch
-		return nil, nil, nil, cr.error
+
+		return c1, recvPayload, nil
 	}
-	circ = cr.Circuit
-	if err := circ.DialRendezvousRaw(cookie, sendPayload); err != nil {
-		return nil, nil, nil, err
+	c1.Close()
+
+	if err := c2.DialRendezvousRaw(cookie, sendPayload); err != nil {
+		c2.Close()
+		return nil, nil, err
 	}
-	return tc, circ, nil, nil
+	return c2, nil, nil
 }
 
 func ND(ctx context.Context, needle *[32]byte, seed []byte) (*Conn, error) {
@@ -133,7 +107,7 @@ func ND(ctx context.Context, needle *[32]byte, seed []byte) (*Conn, error) {
 	}
 	defer nd.Close()
 
-	mid_, err := torch.DownloadMicrodescriptors(nd.dirClient, []*directory.ShortNodeInfo{nd.pick(needle)})
+	mid_, err := torch.DownloadMicrodescriptors(nd.dirClient, []*directory.ShortNodeInfo{Pick(nd.routers, needle)})
 	if err != nil {
 		return nil, err
 	}
@@ -147,11 +121,21 @@ func ND(ctx context.Context, needle *[32]byte, seed []byte) (*Conn, error) {
 		return nil, err
 	}
 
-	return Handshake(ctx, tc, seed, mid.ID[:], mid.NTorOnionKey[:])
+	c1, err := tc.CreateCircuit(ctx, mid.ID[:], mid.NTorOnionKey)
+	if err != nil {
+		return nil, err
+	}
+	c2, err := tc.CreateCircuit(ctx, mid.ID[:], mid.NTorOnionKey)
+	if err != nil {
+		return nil, err
+	}
+	return Handshake(ctx, c1, c2, seed)
 }
 
-func Handshake(ctx context.Context, tc *torch.TorConn, seed, routerID, routerNTorPublic []byte) (*Conn, error) {
-	kdf := hkdf.New(sha256.New, seed, routerID, nil)
+func Handshake(ctx context.Context, c1, c2 *torch.Circuit, sharedSecret []byte) (*Conn, error) {
+	// NOTE: one of the circuits is only needed after a couple of network round
+	// trips, so it may be a good idea to pass in a <-chan *Circuit instead.
+	kdf := hkdf.New(sha256.New, sharedSecret, nil, nil)
 	var cookie [20]byte
 	var authKeyAccept, authKeyDial, continueKey [32]byte
 	if _, err := io.ReadFull(kdf, cookie[:]); err != nil {
@@ -173,7 +157,7 @@ func Handshake(ctx context.Context, tc *torch.TorConn, seed, routerID, routerNTo
 	var theirPK [32]byte
 	vouchDial := secretbox.Seal(nil, pk[:], &[24]byte{}, &authKeyDial)
 
-	tc, circ, theirVouchDial, err := connect(ctx, tc, cookie[:], vouchDial[:], routerID, routerNTorPublic)
+	circ, theirVouchDial, err := connect(ctx, c1, c2, cookie[:], vouchDial[:])
 	if err != nil {
 		return nil, err
 	}
@@ -204,9 +188,8 @@ func Handshake(ctx context.Context, tc *torch.TorConn, seed, routerID, routerNTo
 	var sharedDH [32]byte
 	curve25519.ScalarMult(&sharedDH, sk, &theirPK)
 	ret := &Conn{
-		TorConn: tc,
 		Circuit: circ,
-		KDF:     hkdf.New(sha256.New, append(continueKey[:], sharedDH[:]...), routerID[:], nil),
+		KDF:     hkdf.New(sha256.New, append(continueKey[:], sharedDH[:]...), nil, nil),
 		Bit:     theirVouchDial != nil,
 	}
 	if ret.Bit {

nd/ndconn.go

@@ -10,7 +10,6 @@ import (
 )
 
 type Conn struct {
-	TorConn *torch.TorConn
 	Circuit *torch.Circuit
 	Bit     bool
 	KDF     io.Reader
@@ -22,7 +21,7 @@ type Conn struct {
 }
 
 func (ndc *Conn) Close() error {
-	err := ndc.TorConn.Close()
+	err := ndc.Circuit.Close()
 
 	ndc.writeMu.Lock()
 	defer ndc.writeMu.Unlock()

torch.go

@@ -187,15 +187,21 @@ func niAddr(ni *directory.NodeInfo) string {
 	return fmt.Sprintf("%d.%d.%d.%d:%d", ni.IP[0], ni.IP[1], ni.IP[2], ni.IP[3], ni.Port)
 }
 
-func (t *Torch) Pick(weighWith func(w *directory.BandwidthWeights, n *directory.NodeInfo) int64) *directory.NodeInfo {
+func (t *Torch) WithDirectory(f func(*directory.Directory) interface{}) interface{} {
 	t.RLock()
 	defer t.RUnlock()
+	return f(t.cachedDir)
+}
 
+func (t *Torch) Pick(weighWith func(w *directory.BandwidthWeights, n *directory.NodeInfo) int64) *directory.NodeInfo {
 	weigh := func(n *directory.NodeInfo) int64 {
 		return weighWith(&t.cachedDir.Consensus.BandwidthWeights, n)
 	}
 
-	return directory.Pick(weigh, t.cachedDir.Routers, nil)
+	return t.WithDirectory(func(d *directory.Directory) interface{} {
+		return directory.Pick(weigh, d.Routers, nil)
+	}).(*directory.NodeInfo)
+
 }
 
 func weighRelayWith(w *directory.BandwidthWeights, n *directory.NodeInfo) int64 {