add pub/priv key code to identify, not complete yet

config/config.go

 package config
 
 import (
-	u "github.com/jbenet/go-ipfs/util"
 	"os"
+
+	u "github.com/jbenet/go-ipfs/util"
 )
 
 // Identity tracks the configuration of the local node's identity.
 type Identity struct {
-	PeerID string
+	PeerID  string
+	Address string
 }
 
 // Datastore tracks the configuration of the datastore.
@@ -16,10 +18,15 @@ type Datastore struct {
 	Path string
 }
 
+type SavedPeer struct {
+	Address string
+}
+
 // Config is used to load IPFS config files.
 type Config struct {
 	Identity  *Identity
 	Datastore *Datastore
+	Peers     []*SavedPeer
 }
 
 var defaultConfigFilePath = "~/.go-ipfs/config"

core/core.go

@@ -67,34 +67,10 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 
 	var swap *bitswap.BitSwap
 	if online {
-		maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/4001")
+		swap, err = loadBitswap(cfg, d)
 		if err != nil {
 			return nil, err
 		}
-
-		local := &peer.Peer{
-			ID:        peer.ID(cfg.Identity.PeerID),
-			Addresses: []*ma.Multiaddr{maddr},
-		}
-
-		if len(local.ID) == 0 {
-			mh, err := u.Hash([]byte("blah blah blah ID"))
-			if err != nil {
-				return nil, err
-			}
-			local.ID = peer.ID(mh)
-		}
-
-		net := swarm.NewSwarm(local)
-		err = net.Listen()
-		if err != nil {
-			return nil, err
-		}
-
-		route := dht.NewDHT(local, net, d)
-		route.Start()
-
-		swap = bitswap.NewBitSwap(local, net, d, route)
 	}
 
 	bs, err := bserv.NewBlockService(d, swap)
@@ -115,3 +91,47 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 
 	return n, nil
 }
+
+func loadBitswap(cfg *config.Config, d ds.Datastore) (*bitswap.BitSwap, error) {
+	maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/4001")
+	if err != nil {
+		return nil, err
+	}
+
+	local := &peer.Peer{
+		ID:        peer.ID(cfg.Identity.PeerID),
+		Addresses: []*ma.Multiaddr{maddr},
+	}
+
+	if len(local.ID) == 0 {
+		mh, err := u.Hash([]byte("blah blah blah ID"))
+		if err != nil {
+			return nil, err
+		}
+		local.ID = peer.ID(mh)
+	}
+
+	net := swarm.NewSwarm(local)
+	err = net.Listen()
+	if err != nil {
+		return nil, err
+	}
+
+	route := dht.NewDHT(local, net, d)
+	route.Start()
+
+	for _, p := range cfg.Peers {
+		maddr, err := ma.NewMultiaddr(p.Address)
+		if err != nil {
+			u.PErr("error: %v\n", err)
+			continue
+		}
+
+		_, err = route.Connect(maddr)
+		if err != nil {
+			u.PErr("Bootstrapping error: %v\n", err)
+		}
+	}
+
+	return bitswap.NewBitSwap(local, net, d, route), nil
+}

identify/identify.go

@@ -3,6 +3,13 @@
 package identify
 
 import (
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"errors"
+	"io/ioutil"
+
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
 )
@@ -18,3 +25,65 @@ func Handshake(self, remote *peer.Peer, in, out chan []byte) error {
 
 	return nil
 }
+
+type KeyPair struct {
+	Pub  crypto.PublicKey
+	Priv crypto.PrivateKey
+}
+
+func GenKeypair() (*KeyPair, error) {
+	priv, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		return nil, err
+	}
+
+	return &KeyPair{
+		Priv: priv,
+		Pub:  priv.PublicKey,
+	}, nil
+}
+
+func LoadKeypair(dir string) (*KeyPair, error) {
+	var kp KeyPair
+	pk_b, err := ioutil.ReadFile(dir + "/priv.key")
+	if err != nil {
+		return nil, err
+	}
+
+	priv, err := x509.ParsePKCS1PrivateKey(pk_b)
+	if err != nil {
+		return nil, err
+	}
+
+	kp.Priv = priv
+	kp.Pub = priv.PublicKey
+
+	return &kp, nil
+}
+
+func (pk *KeyPair) ID() (peer.ID, error) {
+	pub_b, err := x509.MarshalPKIXPublicKey(pk.Pub)
+	if err != nil {
+		return nil, err
+	}
+	hash, err := u.Hash(pub_b)
+	if err != nil {
+		return nil, err
+	}
+	return peer.ID(hash), nil
+}
+
+func (kp *KeyPair) Save(dir string) error {
+	switch k := kp.Priv.(type) {
+	case *rsa.PrivateKey:
+		err := k.Validate()
+		if err != nil {
+			return err
+		}
+		pk_b := x509.MarshalPKCS1PrivateKey(k)
+		err = ioutil.WriteFile(dir+"/priv.key", pk_b, 0600)
+		return err
+	default:
+		return errors.New("invalid private key type.")
+	}
+}

routing/dht/dht.go

@@ -2,6 +2,7 @@ package dht
 
 import (
 	"bytes"
+	"crypto/rand"
 	"fmt"
 	"sync"
 	"time"
@@ -637,3 +638,10 @@ func (dht *IpfsDHT) peerFromInfo(pbp *PBDHTMessage_PBPeer) (*peer.Peer, error) {
 
 	return dht.network.GetConnection(peer.ID(pbp.GetId()), maddr)
 }
+
+// Builds up list of peers by requesting random peer IDs
+func (dht *IpfsDHT) Bootstrap() {
+	id := make([]byte, 16)
+	rand.Read(id)
+	dht.FindPeer(peer.ID(id), time.Second*10)
+}

routing/dht/routing.go

@@ -340,6 +340,56 @@ func (dht *IpfsDHT) FindPeer(id peer.ID, timeout time.Duration) (*peer.Peer, err
 	return nil, u.ErrNotFound
 }
 
+func (dht *IpfsDHT) findPeerMultiple(id peer.ID, timeout time.Duration) (*peer.Peer, error) {
+	// Check if were already connected to them
+	p, _ := dht.Find(id)
+	if p != nil {
+		return p, nil
+	}
+
+	routeLevel := 0
+	peers := dht.routingTables[routeLevel].NearestPeers(kb.ConvertPeerID(id), AlphaValue)
+	if len(peers) == 0 {
+		return nil, kb.ErrLookupFailure
+	}
+
+	found := make(chan *peer.Peer)
+	after := time.After(timeout)
+
+	for _, p := range peers {
+		go func(p *peer.Peer) {
+			pmes, err := dht.findPeerSingle(p, id, timeout, routeLevel)
+			if err != nil {
+				u.DErr("getPeer error: %v\n", err)
+				return
+			}
+			plist := pmes.GetPeers()
+			if len(plist) == 0 {
+				routeLevel++
+			}
+			for _, fp := range plist {
+				nxtp, err := dht.peerFromInfo(fp)
+				if err != nil {
+					u.DErr("findPeer error: %v\n", err)
+					continue
+				}
+
+				if nxtp.ID.Equal(dht.self.ID) {
+					found <- nxtp
+					return
+				}
+			}
+		}(p)
+	}
+
+	select {
+	case p := <-found:
+		return p, nil
+	case <-after:
+		return nil, u.ErrTimeout
+	}
+}
+
 // Ping a peer, log the time it took
 func (dht *IpfsDHT) Ping(p *peer.Peer, timeout time.Duration) error {
 	// Thoughts: maybe this should accept an ID and do a peer lookup?