Windows port

Makefile.win32

@@ -0,0 +1,23 @@
+# Makefile for building on Windows using nmake
+
+GOBUILDFLAGS = -ldflags -s
+
+all:
+	if not exist "bin" mkdir bin
+	cd kr& go build $(GOBUILDFLAGS) -o ../bin/kr.exe
+	cd krd/main& go build $(GOBUILDFLAGS) -o ../../bin/krd.exe
+	cd krgpg& go build $(GOBUILDFLAGS) -o ../bin/krgpg.exe
+
+clean:
+	if exist "bin" rmdir /s /q bin
+
+check:
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr/krd
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr/krdclient
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr/kr
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr/krssh
+	go test $(GOBUILDFLAGS) github.com/kryptco/kr/krgpg
+
+vet:
+	go vet github.com/kryptco/kr github.com/kryptco/kr/krd github.com/kryptco/kr/krdclient github.com/kryptco/kr/kr github.com/kryptco/kr/krssh github.com/kryptco/kr/krgpg

analytics_ua_windows.go

@@ -0,0 +1,38 @@
+package kr
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"strings"
+	"sync"
+)
+
+var analytics_user_agent = fmt.Sprintf("Mozilla/5.0 (10.0.15063; Win64) (KHTML, like Gecko) Version/%s kr/%s", CURRENT_VERSION, CURRENT_VERSION)
+
+const analytics_os = "Windows"
+
+var cachedAnalyticsOSVersion *string
+var osVersionMutex sync.Mutex
+
+func getAnalyticsOSVersion() *string {
+	osVersionMutex.Lock()
+	defer osVersionMutex.Unlock()
+	if cachedAnalyticsOSVersion != nil {
+		return cachedAnalyticsOSVersion
+	}
+
+	cmd := exec.Command("cmd", "ver")
+	var out bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err != nil {
+		panic(err)
+	}
+	osStr := strings.Replace(out.String(), "\n", "", -1)
+	osStr = strings.Replace(osStr, "\r\n", "", -1)
+	cachedAnalyticsOSVersion = &osStr
+	return cachedAnalyticsOSVersion
+}

aws_windows.go

@@ -0,0 +1,3 @@
+package kr
+
+const NTP_UPDATE_CMD = "w32tm /resync"

dir_unix.go

@@ -0,0 +1,49 @@
+// +build !windows
+
+package kr
+
+import (
+	"os"
+	"os/user"
+	"path/filepath"
+)
+
+//	Find home directory of logged-in user even when run as sudo
+func UnsudoedHomeDir() (home string) {
+	userName := os.Getenv("SUDO_USER")
+	if userName == "" {
+		userName = os.Getenv("USER")
+	}
+	currentUser, err := user.Lookup(userName)
+	if err == nil && currentUser != nil {
+		home = currentUser.HomeDir
+	} else {
+		log.Notice("falling back to $HOME")
+		home = os.Getenv("HOME")
+		err = nil
+	}
+	if os.Getenv("HOME") != home {
+		os.Setenv("HOME", home)
+	}
+	return
+}
+
+func KrDir() (krPath string, err error) {
+	home := UnsudoedHomeDir()
+	if err != nil {
+		return
+	}
+	krPath = filepath.Join(home, ".kr")
+	err = os.MkdirAll(krPath, os.FileMode(0700))
+	return
+}
+
+func NotifyDir() (krPath string, err error) {
+	home := UnsudoedHomeDir()
+	if err != nil {
+		return
+	}
+	krPath = filepath.Join(home, ".kr", "notify")
+	err = os.MkdirAll(krPath, os.FileMode(0700))
+	return
+}

dir_windows.go

@@ -0,0 +1,42 @@
+// +build windows
+
+package kr
+
+import (
+	"os"
+	"os/user"
+	"path/filepath"
+)
+
+//	Find home directory of logged-in user
+func UnsudoedHomeDir() (home string) {
+	currentUser, err := user.Current()
+	if err == nil && currentUser != nil {
+		home = currentUser.HomeDir
+	} else {
+		log.Notice("falling back to $HOME")
+		home = os.Getenv("HOME")
+		err = nil
+	}
+	return
+}
+
+func KrDir() (krPath string, err error) {
+	home := UnsudoedHomeDir()
+	if err != nil {
+		return
+	}
+	krPath = filepath.Join(home, "appdata", "local", "Kryptco", "kr")
+	err = os.MkdirAll(krPath, os.FileMode(0700))
+	return
+}
+
+func NotifyDir() (notifyPath string, err error) {
+	krDir, err := KrDir()
+	if err != nil {
+		return
+	}
+	notifyPath = filepath.Join(krDir, "notify")
+	err = os.MkdirAll(notifyPath, os.FileMode(0700))
+	return
+}

kr/kr.go

@@ -59,10 +59,10 @@ func pairCommand(c *cli.Context) (err error) {
 	if *nameOpt == "" {
 		nameOpt = nil
 	}
-	return pairOver(kr.DaemonSocketOrFatal(), c.Bool("force"), nameOpt, os.Stdout, os.Stderr)
+	return pairOver(c.Bool("force"), nameOpt, os.Stdout, os.Stderr)
 }
 
-func pairOver(unixFile string, forceUnpair bool, name *string, stdout io.ReadWriter, stderr io.ReadWriter) (err error) {
+func pairOver(forceUnpair bool, name *string, stdout io.ReadWriter, stderr io.ReadWriter) (err error) {
 	//	Listen for incompatible enclave notifications
 	go func() {
 		r, err := kr.OpenNotificationReader("")
@@ -89,7 +89,7 @@ func pairOver(unixFile string, forceUnpair bool, name *string, stdout io.ReadWri
 		}
 	}()
 	if !forceUnpair {
-		meConn, err := kr.DaemonDialWithTimeout(unixFile)
+		meConn, err := kr.DaemonDialWithTimeout()
 		if err != nil {
 			PrintFatal(stderr, "Could not connect to Kryptonite daemon. Make sure it is running by typing \"kr restart\".")
 		}
@@ -98,7 +98,7 @@ func pairOver(unixFile string, forceUnpair bool, name *string, stdout io.ReadWri
 			confirmOrFatal(stderr, "Already paired, unpair current session?")
 		}
 	}
-	putConn, err := kr.DaemonDialWithTimeout(unixFile)
+	putConn, err := kr.DaemonDialWithTimeout()
 	if err != nil {
 		PrintFatal(stderr, "Could not connect to Kryptonite daemon. Make sure it is running by typing \"kr restart\".")
 	}
@@ -145,8 +145,7 @@ func pairOver(unixFile string, forceUnpair bool, name *string, stdout io.ReadWri
 	stdout.Write([]byte("Scan this QR Code with the Kryptonite mobile app to connect it with this workstation. Maximize the window and/or lower your font size if the QR code does not fit."))
 	stdout.Write([]byte("\r\n"))
 
-	//	Check/wait for pairing
-	getConn, err := kr.DaemonDialWithTimeout(unixFile)
+	getConn, err := kr.DaemonDialWithTimeout()
 	if err != nil {
 		PrintFatal(stderr, "Could not connect to Kryptonite daemon. Make sure it is running by typing \"kr restart\".")
 	}
@@ -173,11 +172,11 @@ func pairOver(unixFile string, forceUnpair bool, name *string, stdout io.ReadWri
 
 func unpairCommand(c *cli.Context) (err error) {
 	kr.Analytics{}.PostEventUsingPersistedTrackingID("kr", "unpair", nil, nil)
-	return unpairOver(kr.DaemonSocketOrFatal(), os.Stdout, os.Stderr)
+	return unpairOver(os.Stdout, os.Stderr)
 }
 
-func unpairOver(unixFile string, stdout io.ReadWriter, stderr io.ReadWriter) (err error) {
-	conn, err := kr.DaemonDialWithTimeout(unixFile)
+func unpairOver(stdout io.ReadWriter, stderr io.ReadWriter) (err error) {
+	conn, err := kr.DaemonDialWithTimeout()
 	if err != nil {
 		PrintFatal(stderr, err.Error())
 	}

kr/kr_test.go

@@ -2,25 +2,23 @@ package main
 
 import (
 	"bytes"
-	"os"
 	"testing"
 
-	krd "github.com/kryptco/kr/krd"
+	"github.com/kryptco/kr/krd"
 )
 
 func TestPair(t *testing.T) {
-	ec, _, unixFile := krd.NewLocalUnixServer(t)
-	defer os.Remove(unixFile)
+	ec, _ := krd.NewLocalUnixServer(t)
 	ec.Start()
 	defer ec.Stop()
 
-	testPairSuccess(t, unixFile, ec)
+	testPairSuccess(t, ec)
 }
 
-func testPairSuccess(t *testing.T, unixFile string, ec krd.EnclaveClientI) {
+func testPairSuccess(t *testing.T, ec krd.EnclaveClientI) {
 	stdout := &bytes.Buffer{}
 	stderr := &bytes.Buffer{}
-	err := pairOver(unixFile, true, nil, stdout, stderr)
+	err := pairOver(true, nil, stdout, stderr)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -30,16 +28,15 @@ func testPairSuccess(t *testing.T, unixFile string, ec krd.EnclaveClientI) {
 }
 
 func TestUnpair(t *testing.T) {
-	ec, _, unixFile := krd.NewLocalUnixServer(t)
-	defer os.Remove(unixFile)
+	ec, _ := krd.NewLocalUnixServer(t)
 	ec.Start()
 	defer ec.Stop()
 
-	testPairSuccess(t, unixFile, ec)
+	testPairSuccess(t, ec)
 
 	stdout := &bytes.Buffer{}
 	stderr := &bytes.Buffer{}
-	err := unpairOver(unixFile, stdout, stderr)
+	err := unpairOver(stdout, stderr)
 	if err != nil {
 		t.Fatal(err)
 	}

kr/kr_windows.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/urfave/cli"
+)
+
+func restartCommand(c *cli.Context) (err error) {
+	PrintErr(os.Stderr, "Kryptonite daemon restart from cmdline not supported on Windows.")
+	return
+}
+
+func openBrowser(url string) {
+	exec.Command("cmd", "start", url).Run()
+}
+
+func hasAptGet() bool {
+	return false
+}
+
+func hasYum() bool {
+	return false
+}
+
+func uninstallCommand(c *cli.Context) (err error) {
+	PrintErr(os.Stderr, "Kryptonite uninstall from cmdline not supported on Windows.")
+	return
+}
+
+func upgradeCommand(c *cli.Context) (err error) {
+	PrintErr(os.Stderr, "Kryptonite upgrade from cmdline not supported on Windows.")
+	return
+}

krd/bluetooth_none.go

@@ -1,4 +1,4 @@
-// +build nobluetooth
+// +build nobluetooth windows
 
 package krd
 

krd/enclave_client_test_util.go

@@ -1,14 +1,13 @@
 package krd
 
 import (
-	"net"
-	"os"
-	"path/filepath"
 	"testing"
 	"time"
 
+	"fmt"
 	"github.com/kryptco/kr"
 	"github.com/op/go-logging"
+	"net"
 )
 
 func NewTestEnclaveClient(transport kr.Transport) EnclaveClientI {
@@ -48,23 +47,37 @@ func NewTestEnclaveClientShortTimeouts(transport kr.Transport) EnclaveClientI {
 	return ec
 }
 
-func NewLocalUnixServer(t *testing.T) (ec EnclaveClientI, cs *ControlServer, unixFile string) {
+var listener net.Listener
+
+func NewLocalUnixServer(t *testing.T) (ec EnclaveClientI, cs *ControlServer) {
 	transport := &kr.ResponseTransport{T: t}
 	ec = NewTestEnclaveClient(transport)
 	cs = &ControlServer{ec, kr.SetupLogging("test", logging.INFO, false)}
 
-	randFile, err := kr.Rand128Base62()
-	if err != nil {
-		t.Fatal(err)
-	}
-	unixFile = filepath.Join(os.TempDir(), randFile)
-	l, err := net.Listen("unix", unixFile)
-	if err != nil {
-		t.Fatal(err)
+	if listener == nil {
+		l, err := kr.DaemonListen()
+		if err != nil {
+			t.Fatal(fmt.Errorf("DaemonListen() failure: %s.  Try stopping krd and running tests again", err))
+		}
+		listener = l
 	}
 
 	go func() {
-		err := cs.HandleControlHTTP(l)
+		err := cs.HandleControlHTTP(listener)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	return
+}
+
+func NewLocalUnixServerWithListener(t *testing.T, listener net.Listener) (ec EnclaveClientI, cs *ControlServer) {
+	transport := &kr.ResponseTransport{T: t}
+	ec = NewTestEnclaveClient(transport)
+	cs = &ControlServer{ec, kr.SetupLogging("test", logging.INFO, false)}
+
+	go func() {
+		err := cs.HandleControlHTTP(listener)
 		if err != nil {
 			t.Fatal(err)
 		}

krd/main/krd.go

@@ -12,15 +12,7 @@ import (
 	"github.com/op/go-logging"
 )
 
-func useSyslog() bool {
-	env := os.Getenv("KR_LOG_SYSLOG")
-	if env != "" {
-		return env == "true"
-	}
-	return true
-}
-
-var log *logging.Logger = kr.SetupLogging("krd", logging.INFO, useSyslog())
+var log *logging.Logger = kr.SetupLogging("krd", logging.INFO, UseSyslog())
 
 func main() {
 	krd.SetBTLogger(log)