go-onion-transport

This library contains a Tor transport implementation for libp2p (v0.8.3) that uses an embedded Tor client.

Usage

import (
    "context"
    "crypto/ed25519"
    "crypto/rand"
    "fmt"
    oniontransport "github.com/cpacia/go-onion-transport"
    "github.com/cretz/bine/tor"
    "github.com/ipfs/go-ipfs/core"
    "github.com/ipfs/go-ipfs/repo/fsrepo"
    "github.com/ipsn/go-libtor"
    "github.com/libp2p/go-libp2p"
    "github.com/libp2p/go-libp2p-core/host"
    "github.com/libp2p/go-libp2p-core/peer"
    "github.com/libp2p/go-libp2p-core/peerstore"
    "github.com/libp2p/go-libp2p/config"
    "github.com/multiformats/go-multiaddr"
    madns "github.com/multiformats/go-multiaddr-dns"
    "path"
)

func main() {

    // First create the private key that will be used for the onion address.
    // You will need to persist this key between sessions if you want to use
    // the same onion address each time.
    _, privateKey, err := ed25519.GenerateKey(rand.Reader)
    if err != nil {
        log.Fatal(err)
    }

    // Define a directory for the tor client to use. Inside your application's
    // data directory will do fine.
    torDir := path.Join(dataDir, "tor")

    // Create the embedded Tor client.
    torClient, err := tor.Start(nil, &tor.StartConf{
        ProcessCreator:  libtor.Creator,
        DataDir:         torDir,
        NoAutoSocksPort: true,
        EnableNetwork:   true,
        ExtraArgs:       []string{"--DNSPort", "2121"},
    })
    if err != nil {
        log.Fatal(err)
    }

    // Create the dialer.
    //
    // IMPORTANT: If you are genuinely trying to anonymize your IP you will need to route
    // any non-libp2p traffic through this dialer as well. For example, any HTTP requests
    // you make MUST go through this dialer.
    dialer, err := torClient.Dialer(context.Background(), nil)
    if err != nil {
        log.Fatal(err)
    }

    // Create the onion service.
    onionService, err := torClient.Listen(context.Background(), &tor.ListenConf{
        RemotePorts: []int{9003},
        Version3:    true,
        Key:         privateKey,
    })
    if err != nil {
        log.Fatal(err)
    }

    // Override the default lip2p DNS resolver. We need this because libp2p address may contain a 
    // DNS hostname that will be resolved before dialing. If we do not configure the resolver to 
    // use Tor we will blow any anonymity we gained by using Tor.
    // 
    // Note you must enter the DNS resolver address that was used when creating the Tor client.
    madns.DefaultResolver = oniontransport.NewTorResover("localhost:2121")

    // If this option is true then the transport will only attempt to dial out to onion
    // addresses. If libp2p requests to dial out on another type of address, TCP for example,
    // it will respond saying it can't dial that address.
    //
    // If your goal is to use this transport in conjunction with other non-Tor transports,
    // for example in a "dual stack" configuration, then you likely only want to route only
    // outgoing connections to onion addresses through this transport and let outgoing TCP
    // connections go through a faster transport. In this case this option should be true.
    // Note that such a configuration would NOT be anonymous.
    //
    // If this option is set to false then the this transport will attempt to dial out to
    // both onion addresses and TCP addresses.
    dialOnionOnly := false

    // Create the libp2p transport option.
    transportOpt := libp2p.Transport(oniontransport.NewOnionTransportC(dialer, onionService, dialOnionOnly))

    // Create address option.
    onionAddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/onion3/%s:9003", onionService.ID))
    if err != nil {
        log.Fatal(err)
    }
    addressOpt := libp2p.ListenAddrs(onionAddr)

    // The transport option is passed in along with the FallbackDefaults options. FallbackDefaults
    // only applies the default options if no other option is provided. In this case we provided
    // the Tor transport so this configuration should ONLY use the Tor transport and no other transports.
    //
    // Using libp2p.Defaults instead of libp2p.FallbackDefaults would append the Tor transport to the
    // the existing list of transports.
    peerHost, err := libp2p.New(context.Background(), transportOpt, addressOpt, libp2p.FallbackDefaults)
    if err != nil {
        log.Fatal(err)
    }

    // Libp2p is now configured to use Tor.

    // If you want to configure IPFS to use Tor you will need to create a new hostOption.
    constructPeerHost := func(ctx context.Context, id peer.ID, ps peerstore.Peerstore, options ...libp2p.Option) (host.Host, error) {
        pkey := ps.PrivKey(id)
        if pkey == nil {
            return nil, fmt.Errorf("missing private key for node ID: %s", id.Pretty())
        }
        options = append([]libp2p.Option{libp2p.Identity(pkey), libp2p.Peerstore(ps)}, options...)

        cfg := &config.Config{}
        if err := cfg.Apply(options...); err != nil {
            return nil, err
        }

        cfg.Transports = nil
        if err := transportOpt(cfg); err != nil {
            return nil, err
        }
        return cfg.NewNode(ctx)
    }

    // You can set the swarm onion address in the config if you want. Or set it here.
    ipfsRepo, err := fsrepo.Open(ipfsDir)
    if err != nil {
        log.Fatal(err)
    }

    ipfsConfig, err := ipfsRepo.Config()
    if err != nil {
        log.Fatal(err)
    }

    ipfsConfig.Addresses.Swarm = []string{fmt.Sprintf("/onion3/%s:9003", onionService.ID)}

    // New IPFS build config
    ncfg := &core.BuildCfg{
        Repo: ipfsRepo,
        Host: constructPeerHost,
    }

    // Construct IPFS node.
    ipfsNode, err := core.NewNode(context.Background(), ncfg)
    if err != nil {
        log.Fatal(err)
    }

    // IPFS is now configured to use Tor.

    // WARNING: Passing a hostname into an IPNS Resolve will likely route the the DNS name resolution
    // in the clear and not through Tor. It should be a small change to IPFS to use the madns.DefaultResover
    // but we need to get it merged and released first. 
}