Merge branch 'master' into ssh

Author: N2D4

.gitignore

@@ -51,3 +51,8 @@ tools/pathdb_dump/pathdb_dump
 netcat/netcat
 ssh/client/client
 ssh/server/server
+roughtime/timeclient/timeclient
+roughtime/timeserver/timeserver
+
+# vscode workspace
+*.code-workspace

Makefile

@@ -1,8 +1,7 @@
 .PHONY: all clean
 
 ROOT_DIR=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
-# TODO: missing roughtime/timeserver roughtime/timeclient
-SRCDIRS= helloworld sensorapp/sensorserver sensorapp/sensorfetcher camerapp/imageserver camerapp/imagefetcher bwtester/bwtestserver bwtester/bwtestclient webapp bat bat/example_server tools/pathdb_dump netcat ssh/client ssh/server
+SRCDIRS= helloworld sensorapp/sensorserver sensorapp/sensorfetcher camerapp/imageserver camerapp/imagefetcher bwtester/bwtestserver bwtester/bwtestclient webapp bat bat/example_server tools/pathdb_dump roughtime/timeserver roughtime/timeclient ssh/client ssh/server netcat
 TARGETS = $(foreach D,$(SRCDIRS),$(D)/$(notdir $(D)))
 
 all: $(TARGETS)
@@ -13,6 +12,9 @@ deps:
 clean:
 	@$(foreach d,$(SRCDIRS),cd $(ROOT_DIR)/$(d) && go clean;)
 
+install: all
+	@$(foreach d,$(SRCDIRS), cd $(ROOT_DIR)/$(d); cp $(shell basename $(d)) ~/go/bin;)
+
 # using eval to create as many rules as we have $TARGETS
 # each target corresponds to the binary file name (e.g. sensorapp/sensorserver/sensorserver)
 define gobuild_tmpl = 

README.md

@@ -8,7 +8,7 @@ More information on [SCION](https://www.scion-architecture.net/), and [tutorials
 
 To build:
 1. run once the provided script `deps.sh` to set up the dependencies
-2. run `make` to build all projects
+2. run `make install` to build all projects and install into `$GOPATH/bin`
 
 
 ## bat

bat/bat.go

@@ -74,7 +74,6 @@ var (
 )
 
 func init() {
-
 	flag.BoolVar(&interactive, "in", false, "Lets user choose the path to destination")
 	flag.BoolVar(&ver, "v", false, "Print Version Number")
 	flag.BoolVar(&ver, "version", false, "Print Version Number")

bwtester/bwtestserver/bwtestserver.go

@@ -115,11 +115,11 @@ func main() {
 	// Create the SCION UDP socket
 	if len(serverCCAddrStr) == 0 {
 		serverCCAddr, err = scionutil.GetLocalhost()
-		serverCCAddr.Host.L4 = addr.NewL4UDPInfo(uint16(serverPort))
 		if err != nil {
 			printUsage()
-			LogFatal("Unable to start server", "err", err)
+			LogFatal("Unable to start server, please provide the server address manually", "err", err)
 		}
+		serverCCAddr.Host.L4 = addr.NewL4UDPInfo(uint16(serverPort))
 	} else {
 		serverCCAddr, err = snet.AddrFromString(serverCCAddrStr)
 		if err != nil {

camerapp/imageserver/imageserver.go

@@ -155,8 +155,8 @@ func main() {
 		}
 	} else {
 		server, err = scionutil.GetLocalhost()
-		server.Host.L4 = addr.NewL4UDPInfo(uint16(serverPort))
 		check(err)
+		server.Host.L4 = addr.NewL4UDPInfo(uint16(serverPort))
 	}
 
 	if sciondFromIA {

lib/scionutil/hosts.go

@@ -18,23 +18,39 @@ import (
 	"bytes"
 	"fmt"
 	"io/ioutil"
-	"log"
+	"os"
+	"path"
 	"regexp"
 	"strings"
+	"time"
 
+	"github.com/netsec-ethz/rains/pkg/rains"
 	libaddr "github.com/scionproto/scion/go/lib/addr"
+	"github.com/scionproto/scion/go/lib/snet"
 )
 
 type scionAddress struct {
 	ia libaddr.IA
 	l3 libaddr.HostAddr
 }
 
+// hosts file
 var (
 	hostFilePath = "/etc/hosts"
 	addrRegexp   = regexp.MustCompile(`^(?P<ia>\d+-[\d:A-Fa-f]+),\[(?P<host>[^\]]+)\]`)
-	hosts        map[string]scionAddress // hostname -> scionAddress
-	revHosts     map[string][]string     // SCION address w/o port -> hostnames
+	hosts        = make(map[string]scionAddress) // hostname -> scionAddress
+	revHosts     = make(map[string][]string)     // SCION address w/o port -> hostnames
+)
+
+// RAINS
+var (
+	rainsConfigPath = path.Join(os.Getenv("SC"), "gen", "rains.cfg")
+	ctx             = "."                    // use global context
+	qType           = rains.OTScionAddr4     // request SCION IPv4 addresses
+	qOpts           = []rains.Option{}       // no options
+	expire          = 5 * time.Minute        // sensible expiry date?
+	timeout         = 500 * time.Millisecond // timeout for query
+	rainsServer     *snet.Addr               // resolver address
 )
 
 const (
@@ -43,19 +59,20 @@ const (
 )
 
 func init() {
+	// parse hosts file
 	hostsFile, err := readHostsFile()
-	if err != nil {
-		hostsFile = []byte{}
-	}
-	parseHostsFile(hostsFile)
-	if err != nil {
-		log.Fatal(err)
+	if err == nil {
+		parseHostsFile(hostsFile)
 	}
+
+	// read RAINS server address
+	rainsServer = readRainsConfig()
 }
 
 // AddHost adds a host to the map of known hosts
 // An error is returned if the address has a wrong format or
 // the hostname already exists
+// The added host will not persist between program executions
 func AddHost(hostname, address string) error {
 	if addrs, ok := hosts[hostname]; ok {
 		return fmt.Errorf("Host %q already exists, address(es): %v", hostname, addrs)
@@ -72,14 +89,35 @@ func AddHost(hostname, address string) error {
 
 // GetHostByName returns the IA and HostAddr corresponding to hostname
 func GetHostByName(hostname string) (libaddr.IA, libaddr.HostAddr, error) {
+	// try to resolve hostname locally
 	addr, ok := hosts[hostname]
-	if !ok {
-		return libaddr.IA{}, nil, fmt.Errorf("Address for host %q not found", hostname)
+	if ok {
+		return addr.ia, addr.l3, nil
+	}
+
+	if rainsServer == nil {
+		return libaddr.IA{}, nil, fmt.Errorf("Could not resolve %q, no RAINS server configured", hostname)
 	}
-	return addr.ia, addr.l3, nil
+
+	// fall back to RAINS
+
+	// TODO(chaehni): This call can sometimes cause a timeout even though the server is reachable (see issue #221)
+	// The timeout value has been decreased to counter this behavior until the problem is resolved.
+	reply, err := rains.Query(hostname, ctx, []rains.Type{qType}, qOpts, expire, timeout, rainsServer)
+	if err != nil {
+		return libaddr.IA{}, nil, fmt.Errorf("Address for host %q not found: %v", hostname, err)
+	}
+	scionAddr, err := addrFromString(reply[qType])
+	if err != nil {
+		return libaddr.IA{}, nil, fmt.Errorf("Address for host %q invalid: %v", hostname, err)
+	}
+
+	return scionAddr.ia, scionAddr.l3, nil
+
 }
 
 // GetHostnamesByAddress returns the hostnames corresponding to address
+// TODO: (chaehni) RAINS address query to resolve address to name
 func GetHostnamesByAddress(address string) ([]string, error) {
 	match := addrRegexp.FindString(address)
 	host, ok := revHosts[match]
@@ -98,8 +136,6 @@ func readHostsFile() ([]byte, error) {
 }
 
 func parseHostsFile(hostsFile []byte) {
-	hosts = make(map[string]scionAddress)
-	revHosts = make(map[string][]string)
 	lines := bytes.Split(hostsFile, []byte("\n"))
 	for _, line := range lines {
 		fields := strings.Fields(string(line))
@@ -124,8 +160,23 @@ func parseHostsFile(hostsFile []byte) {
 	}
 }
 
+func readRainsConfig() *snet.Addr {
+	bs, err := ioutil.ReadFile(rainsConfigPath)
+	if err != nil {
+		return nil
+	}
+	addr, err := snet.AddrFromString(strings.TrimSpace(string(bs)))
+	if err != nil {
+		return nil
+	}
+	return addr
+}
+
 func addrFromString(addr string) (scionAddress, error) {
 	parts := addrRegexp.FindStringSubmatch(addr)
+	if parts == nil {
+		return scionAddress{}, fmt.Errorf("No valid SCION address: %q", addr)
+	}
 	ia, err := libaddr.IAFromString(parts[iaIndex])
 	if err != nil {
 		return scionAddress{}, fmt.Errorf("Invalid IA string: %v", parts[iaIndex])

lib/scionutil/initialization.go

@@ -67,6 +67,9 @@ func GetDefaultDispatcher() string {
 // GetLocalhost returns a local SCION address an application can bind to
 func GetLocalhost() (*snet.Addr, error) {
 	str, err := GetLocalhostString()
+	if err != nil {
+		return nil, err
+	}
 	addr, err := snet.AddrFromString(str)
 	if err != nil {
 		return nil, err

lib/shttp/transport.go

@@ -19,15 +19,19 @@ package shttp
 
 import (
 	"crypto/tls"
+	"errors"
+	"fmt"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
+	"strings"
 	"sync"
 
 	"github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/h2quic"
 	"github.com/netsec-ethz/scion-apps/lib/scionutil"
-	libaddr "github.com/scionproto/scion/go/lib/addr"
+	"github.com/scionproto/scion/go/lib/addr"
 	"github.com/scionproto/scion/go/lib/snet"
 	// "github.com/scionproto/scion/go/lib/snet/squic"
 )
@@ -91,9 +95,20 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 		return nil, initErr
 	}
 
+	// If req.URL.Host is a SCION address, we need to mangle it so it passes through
+	// h2quic without tripping up.
+	raddr, err := snet.AddrFromString(req.URL.Host)
+	if err == nil {
+		tmp := *req
+		tmp.URL = new(url.URL)
+		*tmp.URL = *req.URL
+		tmp.URL.Host = mangleSCIONAddr(raddr)
+		req = &tmp
+	}
+
 	// set the dial function and QuicConfig once for each Transport
 	t.dialOnce.Do(func() {
-		dial := func(network, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.Session, error) {
+		dial := func(network, addrStr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.Session, error) {
 
 			/* TODO(chaehni):
 			RequestConnectionIDOmission MUST not be set to 'true' when a connection is dialed using an existing net.PacketConn
@@ -105,20 +120,28 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 			*/
 			cfg.RequestConnectionIDOmission = false
 
-			host, port, err := net.SplitHostPort(addr)
+			host, port, err := net.SplitHostPort(addrStr)
 			if err != nil {
 				return nil, err
 			}
-			ia, l3, err := scionutil.GetHostByName(host)
+
+			var ia addr.IA
+			var l3 addr.HostAddr
+			if isMangledSCIONAddr(host) {
+				ia, l3, err = unmangleSCIONAddr(host)
+			} else {
+				ia, l3, err = scionutil.GetHostByName(host)
+			}
 			if err != nil {
 				return nil, err
 			}
 			p, err := strconv.ParseUint(port, 10, 16)
 			if err != nil {
 				p = 443
 			}
-			l4 := libaddr.NewL4UDPInfo(uint16(p))
-			raddr := &snet.Addr{IA: ia, Host: &libaddr.AppAddr{L3: l3, L4: l4}}
+			l4 := addr.NewL4UDPInfo(uint16(p))
+			raddr := &snet.Addr{IA: ia, Host: &addr.AppAddr{L3: l3, L4: l4}}
+
 			return t.squicDialSCION(nil, t.LAddr, raddr, cfg)
 		}
 		t.rt = &h2quic.RoundTripper{
@@ -131,6 +154,48 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 	return t.rt.RoundTripOpt(req, opt)
 }
 
+// mangleSCIONAddr encodes the given SCION address so that it can be safely
+// used in the host part of a URL.
+func mangleSCIONAddr(raddr *snet.Addr) string {
+
+	// The HostAddr will be either IPv4 or IPv6 (not a HostSVC-addr).
+	// To make this a valid host string for a URL, replace : for IPv6 addresses by ~. There will
+	// not be any other tildes, so no need to escape them.
+	l3 := raddr.Host.L3.String()
+	l3_mangled := strings.Replace(l3, ":", "~", -1)
+
+	u := fmt.Sprintf("__%s__%s__", raddr.IA.FileFmt(false), l3_mangled)
+	if raddr.Host.L4 != nil {
+		u += fmt.Sprintf(":%d", raddr.Host.L4.Port())
+	}
+	return u
+}
+
+// isMangledSCIONAddr checks if this is an address previously encoded with mangleSCIONAddr
+// without port, *after* SplitHostPort has been applied.
+func isMangledSCIONAddr(host string) bool {
+
+	parts := strings.Split(host, "__")
+	return len(parts) == 4 && len(parts[0]) == 0 && len(parts[3]) == 0
+}
+
+// unmangleSCIONAddr decodes and parses a SCION-address previously encoded with mangleSCIONAddr
+// without port, i.e. *after* SplitHostPort has been applied.
+func unmangleSCIONAddr(host string) (addr.IA, addr.HostAddr, error) {
+
+	parts := strings.Split(host, "__")
+	ia, err := addr.IAFromFileFmt(parts[1], false)
+	if err != nil {
+		return addr.IA{}, nil, err
+	}
+	l3_str := strings.Replace(parts[2], "~", ":", -1)
+	l3 := addr.HostFromIPStr(l3_str)
+	if l3 == nil {
+		return addr.IA{}, nil, errors.New("Could not parse IP in SCION-address")
+	}
+	return ia, l3, nil
+}
+
 // Close closes the QUIC connections that this RoundTripper has used
 func (t *Transport) Close() error {
 	err := t.rt.Close()

netcat/README.md

@@ -3,7 +3,15 @@ A SCION port of the netcat process.
 
 
 ## Usage
-```./netcat <host> <port>```
+```
+./netcat <host> <port>
+./netcat -l <port>
+```
+
+Remember to generate a TLS certificate first (this will generate them in the current working directory):
+```
+openssl req -newkey rsa:2048 -nodes -keyout ./key.pem -x509 -days 365 -out ./certificate.pem
+```
 
 See `./netcat -h` for more.