Split key generation out in helper

Support SAMv3.3 PRIMARY sessions and all 3 types of SubSessions

See merge request idk/sam3!1

Makefile

@@ -1,6 +1,6 @@
 
 USER_GH=eyedeekay
-VERSION=0.32.32
+VERSION=0.33.001
 packagename=sam3
 
 echo:

README.md

@@ -57,6 +57,8 @@ func client(server I2PAddr) {
 func main() {
 	sam, _ := NewSAM(yoursam)
 	keys, _ := sam.NewKeys()
+	stream, _ := sam.NewStreamSession("serverTun", keys, Options_Medium)
+	listener, _ := stream.Listen()
 	go client(keys.Addr())
 	stream, _ := sam.NewStreamSession("serverTun", keys, Options_Medium)
 	listener, _ := stream.Listen()

datagram.go

@@ -67,6 +67,33 @@ func (s *DatagramSession) B32() string {
 	return s.keys.Addr().Base32()
 }
 
+func (s *DatagramSession) Dial(net string, addr string) (*DatagramSession, error) {
+	netaddr, err := s.Lookup(addr)
+	if err != nil {
+		return nil, err
+	}
+	return s.DialI2PRemote(net, netaddr)
+}
+
+func (s *DatagramSession) DialRemote(net, addr string) (net.PacketConn, error) {
+	netaddr, err := s.Lookup(addr)
+	if err != nil {
+		return nil, err
+	}
+	return s.DialI2PRemote(net, netaddr)
+}
+
+func (s *DatagramSession) DialI2PRemote(net string, addr net.Addr) (*DatagramSession, error) {
+	switch addr.(type) {
+	case *i2pkeys.I2PAddr:
+		s.remoteAddr = addr.(*i2pkeys.I2PAddr)
+	case i2pkeys.I2PAddr:
+		i2paddr := addr.(i2pkeys.I2PAddr)
+		s.remoteAddr = &i2paddr
+	}
+	return s, nil
+}
+
 func (s *DatagramSession) RemoteAddr() net.Addr {
 	return s.remoteAddr
 }

debian/files

@@ -0,0 +1 @@
+golang-github-eyedeekay-sam3_0.3.2.32_source.buildinfo devel optional

go.mod

@@ -2,3 +2,11 @@ module github.com/eyedeekay/sam3
 
 go 1.12
 
+require (
+	github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23
+	github.com/google/renameio v1.0.0 // indirect
+	github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33
+	github.com/rogpeppe/go-internal v1.6.2 // indirect
+	golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b // indirect
+	honnef.co/go/tools v0.0.1-2020.1.6 // indirect
+)

go.sum

@@ -0,0 +1,88 @@
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/agl/ed25519 v0.0.0-20200225211852-fd4d107ace12 h1:iPf1jQ8yKTms6k6L5vYSE7RZJpjEe5vLTOmzRZdpnKc=
+github.com/cryptix/go v1.3.1 h1:I9opbROgEpldI0PwkMku0UY2DLFYgelZd9u0uaxmMgY=
+github.com/cryptix/go v1.3.1/go.mod h1:mFQotm9rTzptzvNjJM+1vSIDa/rVOVqMu0889GIXg70=
+github.com/cryptix/goSam v0.1.0 h1:lKXtrTv3Kd6+eIuNtcq3zPShJEVRqw+lQwmh49HmC7k=
+github.com/cryptix/goSam v0.1.0/go.mod h1:7ewkjhXT8V5RG07pvWUOHHtMahvGbeKlEv8ukUyRiTA=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/eyedeekay/goSam v0.32.30 h1:mMlZNE2oISdjjjpgfN17W56tn9F8rD/Jc2tsjTDDFYg=
+github.com/eyedeekay/goSam v0.32.30/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
+github.com/eyedeekay/goSam v0.32.31-0.20210122211024-dddd8ea916d6 h1:seMFdfTWvmAsyj9jYPZATBJiJu5gHPsvJJk4Ruo2npQ=
+github.com/eyedeekay/goSam v0.32.31-0.20210122211024-dddd8ea916d6/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
+github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23 h1:AHm/EzBilSQH+RFgEuslnlCpVQd88MQWx7KHW/VIQlc=
+github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
+github.com/eyedeekay/sam3 v0.32.32/go.mod h1:qRA9KIIVxbrHlkj+ZB+OoxFGFgdKeGp1vSgPw26eOVU=
+github.com/getlantern/context v0.0.0-20190109183933-c447772a6520/go.mod h1:L+mq6/vvYHKjCX2oez0CgEAJmbq1fbb/oNJIWQkBybY=
+github.com/getlantern/errors v1.0.1/go.mod h1:l+xpFBrCtDLpK9qNjxs+cHU6+BAdlBaxHqikB6Lku3A=
+github.com/getlantern/go-socks5 v0.0.0-20171114193258-79d4dd3e2db5/go.mod h1:kGHRXch95rnGLHjER/GhhFiHvfnqNz7KqWD9kGfATHY=
+github.com/getlantern/golog v0.0.0-20201105130739-9586b8bde3a9/go.mod h1:ZyIjgH/1wTCl+B+7yH1DqrWp6MPJqESmwmEQ89ZfhvA=
+github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7/go.mod h1:dD3CgOrwlzca8ed61CsZouQS5h5jIzkK9ZWrTcf0s+o=
+github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55/go.mod h1:6mmzY2kW1TOOrVy+r41Za2MxXM+hhqTtY3oBKd2AgFA=
+github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd/go.mod h1:wKdY0ikOgzrWSeB9UyBVKPRhjXQ+vTb+BPeJuypUuNE=
+github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
+github.com/getlantern/ops v0.0.0-20200403153110-8476b16edcd6/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
+github.com/go-kit/kit v0.6.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-stack/stack v1.7.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/renameio v1.0.0 h1:xhp2CnJmgQmpJU4RY8chagahUq5mbPPAbiSQstKpVMA=
+github.com/google/renameio v1.0.0/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
+github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/miolini/datacounter v0.0.0-20171104152933-fd4e42a1d5e0 h1:clkDYGefEWUCwyCrwYn900sOaVGDpinPJgD0W6ebEjs=
+github.com/miolini/datacounter v0.0.0-20171104152933-fd4e42a1d5e0/go.mod h1:P6fDJzlxN+cWYR09KbE9/ta+Y6JofX9tAUhJpWkWPaM=
+github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c/go.mod h1:X07ZCGwUbLaax7L0S3Tw4hpejzu63ZrrQiUe6W0hcy0=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33 h1:dyyWDK0yzlZ8ay89Oe5ZIRtscacUjFyPUFGChrgMXRg=
+github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33/go.mod h1:BjmVxzAnkLeoEbqHEerI4eSw6ua+RaIB0S4jMV21RAs=
+github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.6.2 h1:aIihoIOHCiLZHxyoNQ+ABL4NKhFTgKLBdMLyEAh98m0=
+github.com/rogpeppe/go-internal v1.6.2/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200410194907-79a7a3126eef h1:RHORRhs540cYZYrzgU2CPUyykkwZM78hGdzocOo9P8A=
+golang.org/x/tools v0.0.0-20200410194907-79a7a3126eef/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b h1:Lq5JUTFhiybGVf28jB6QRpqd13/JPOaCnET17PVzYJE=
+golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+honnef.co/go/tools v0.0.1-2020.1.6 h1:W18jzjh8mfPez+AwGLxmOImucz/IFjpNlrKVnaj2YVc=
+honnef.co/go/tools v0.0.1-2020.1.6/go.mod h1:pyyisuGw24ruLjrr1ddx39WE0y9OooInRzEYLhQB2YY=

helper/helper.go

@@ -19,57 +19,74 @@ func NetListener(name, samaddr, keyspath string) (net.Listener, error) {
 // exist, keys will be generated and stored in that file.
 func I2PListener(name, samaddr, keyspath string) (*sam3.StreamListener, error) {
 	log.Printf("Starting and registering I2P service, please wait a couple of minutes...")
-	sam, err := sam3.NewSAM(samaddr)
-	if err != nil {
-		log.Fatalf("error connecting to SAM to %s: %s", samaddr, err)
-	}
-	var keys *i2pkeys.I2PKeys
-	if _, err := os.Stat(keyspath + ".i2p.private"); os.IsNotExist(err) {
-		f, err := os.Create(keyspath + ".i2p.private")
-		if err != nil {
-			log.Fatalf("unable to open I2P keyfile for writing: %s", err)
-		}
-		defer f.Close()
-		tkeys, err := sam.NewKeys()
-		if err != nil {
-			log.Fatalf("unable to generate I2P Keys, %s", err)
-		}
-		keys = &tkeys
-		err = i2pkeys.StoreKeysIncompat(*keys, f)
-		if err != nil {
-			log.Fatalf("unable to save newly generated I2P Keys, %s", err)
-		}
-	} else {
-		tkeys, err := i2pkeys.LoadKeys(keyspath + ".i2p.private")
-		if err != nil {
-			log.Fatalf("unable to load I2P Keys: %e", err)
-		}
-		keys = &tkeys
-	}
-	stream, err := sam.NewStreamSession(name, *keys, sam3.Options_Medium)
-	if err != nil {
-		log.Fatalf("error creating I2P streaming connection %s: %s, %s.", name, err, *keys)
-	}
-	listener, err := stream.Listen()
-
-	err = ioutil.WriteFile(keyspath+".i2p.public.txt", []byte(keys.Addr().Base32()), 0644)
-	if err != nil {
-		log.Fatalf("error storing I2P base32 address in adjacent text file, %s", err)
+	listener, err := I2PStreamSession(name, samaddr, keyspath)
 
+	if keyspath != "" {
+		err = ioutil.WriteFile(keyspath+".i2p.public.txt", []byte(listener.Keys().Addr().Base32()), 0644)
+		if err != nil {
+			log.Fatalf("error storing I2P base32 address in adjacent text file, %s", err)
+		}
 	}
-	return listener, err
+	log.Printf("Listening on: %s", listener.Addr().Base32())
+	return listener.Listen()
 }
 
 // I2PStreamSession is a convenience function which returns a sam3.StreamSession instead
 // of a sam3.StreamListener. It also takes care of setting a persisitent key on behalf
 // of the user.
 func I2PStreamSession(name, samaddr, keyspath string) (*sam3.StreamSession, error) {
-	log.Printf("Starting and registering I2P service, please wait a couple of minutes...")
+	log.Printf("Starting and registering I2P session...")
 	sam, err := sam3.NewSAM(samaddr)
 	if err != nil {
 		log.Fatalf("error connecting to SAM to %s: %s", samaddr, err)
 	}
-	var keys *i2pkeys.I2PKeys
+	keys, err := GenerateOrLoadKeys(keyspath, sam)
+	if err != nil {
+		return nil, err
+	}
+	stream, err := sam.NewStreamSession(name, *keys, sam3.Options_Medium)
+	return stream, err
+}
+
+// I2PDataGramsession is a convenience function which returns a sam3.DatagramSession.
+// It also takes care of setting a persisitent key on behalf of the user.
+func I2PDatagramSession(name, samaddr, keyspath string) (*sam3.DatagramSession, error) {
+	log.Printf("Starting and registering I2P session...")
+	sam, err := sam3.NewSAM(samaddr)
+	if err != nil {
+		log.Fatalf("error connecting to SAM to %s: %s", samaddr, err)
+	}
+	keys, err := GenerateOrLoadKeys(keyspath, sam)
+	if err != nil {
+		return nil, err
+	}
+	gram, err := sam.NewDatagramSession(name, *keys, sam3.Options_Medium, 0)
+	return gram, err
+}
+
+// I2PPrimarySession is a convenience function which returns a sam3.PrimarySession.
+// It also takes care of setting a persisitent key on behalf of the user.
+func I2PPrimarySession(name, samaddr, keyspath string) (*sam3.PrimarySession, error) {
+	log.Printf("Starting and registering I2P session...")
+	sam, err := sam3.NewSAM(samaddr)
+	if err != nil {
+		log.Fatalf("error connecting to SAM to %s: %s", samaddr, err)
+	}
+	keys, err := GenerateOrLoadKeys(keyspath, sam)
+	if err != nil {
+		return nil, err
+	}
+	gram, err := sam.NewPrimarySession(name, *keys, sam3.Options_Medium)
+	return gram, err
+}
+
+func GenerateOrLoadKeys(keyspath string, sam *sam3.SAM) (keys *i2pkeys.I2PKeys, err error) {
+	if sam == nil {
+		sam, err = sam3.NewSAM("127.0.0.1:7657")
+		if err != nil {
+			return nil, err
+		}
+	}
 	if _, err := os.Stat(keyspath + ".i2p.private"); os.IsNotExist(err) {
 		f, err := os.Create(keyspath + ".i2p.private")
 		if err != nil {
@@ -92,6 +109,9 @@ func I2PStreamSession(name, samaddr, keyspath string) (*sam3.StreamSession, erro
 		}
 		keys = &tkeys
 	}
-	stream, err := sam.NewStreamSession(name, *keys, sam3.Options_Medium)
-	return stream, err
+	return keys, nil
+}
+
+func GenerateKeys(keyspath string) (keys *i2pkeys.I2PKeys, err error) {
+	return GenerateOrLoadKeys(keyspath, nil)
 }

i2pkeys/I2PAddr.go

@@ -2,6 +2,9 @@ package i2pkeys
 
 import (
 	"bytes"
+	"crypto"
+	"crypto/ed25519"
+	"crypto/rand"
 	"crypto/sha256"
 	"encoding/base32"
 	"encoding/base64"
@@ -9,6 +12,8 @@ import (
 	"io"
 	"os"
 	"strings"
+
+	"github.com/eyedeekay/goSam"
 )
 
 var (
@@ -89,17 +94,75 @@ func StoreKeys(k I2PKeys, r string) error {
 	return StoreKeysIncompat(k, fi)
 }
 
+func (k I2PKeys) Network() string {
+	return k.Address.Network()
+}
+
 // Returns the public keys of the I2PKeys.
 func (k I2PKeys) Addr() I2PAddr {
 	return k.Address
 }
 
+func (k I2PKeys) Public() crypto.PublicKey {
+	return k.Address
+}
+
+func (k I2PKeys) Private() []byte {
+	src := strings.Split(k.String(), k.Addr().String())[0]
+	var dest []byte
+	_, err := i2pB64enc.Decode(dest, []byte(src))
+	panic(err)
+	return dest
+}
+
+type SecretKey interface {
+	Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
+}
+
+func (k I2PKeys) SecretKey() SecretKey {
+	var pk ed25519.PrivateKey = k.Private()
+	return pk
+}
+
+func (k I2PKeys) PrivateKey() crypto.PrivateKey {
+	var pk ed25519.PrivateKey = k.Private()
+	_, err := pk.Sign(rand.Reader, []byte("nonsense"), crypto.Hash(0))
+	if err != nil {
+		//TODO: Elgamal, P256, P384, P512, GOST? keys?
+	}
+	return pk
+}
+
+func (k I2PKeys) Ed25519PrivateKey() *ed25519.PrivateKey {
+	return k.SecretKey().(*ed25519.PrivateKey)
+}
+
+/*func (k I2PKeys) ElgamalPrivateKey() *ed25519.PrivateKey {
+	return k.SecretKey().(*ed25519.PrivateKey)
+}*/
+
+//func (k I2PKeys) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
+//return k.SecretKey().(*ed25519.PrivateKey).Decrypt(rand, msg, opts)
+//}
+
+func (k I2PKeys) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error) {
+	return k.SecretKey().(*ed25519.PrivateKey).Sign(rand, digest, opts)
+}
+
 // Returns the keys (both public and private), in I2Ps base64 format. Use this
 // when you create sessions.
 func (k I2PKeys) String() string {
 	return k.Both
 }
 
+func (k I2PKeys) HostnameEntry(hostname string, opts crypto.SignerOpts) (string, error) {
+	sig, err := k.Sign(rand.Reader, []byte(hostname), opts)
+	if err != nil {
+		return "", err
+	}
+	return string(sig), nil
+}
+
 // I2PAddr represents an I2P destination, almost equivalent to an IP address.
 // This is the humongously huge base64 representation of such an address, which
 // really is just a pair of public keys and also maybe a certificate. (I2P hides
@@ -148,9 +211,9 @@ func (a I2PAddr) Base64() string {
 	return string(a)
 }
 
-// Returns the I2P destination (base64-encoded)
+// Returns the I2P destination (base32-encoded)
 func (a I2PAddr) String() string {
-	return string(a)
+	return string(a.Base32())
 }
 
 // Returns "I2P"
@@ -233,3 +296,30 @@ func (addr I2PAddr) DestHash() (h I2PDestHash) {
 func Base32(anything string) string {
 	return I2PAddr(anything).Base32()
 }
+
+func NewDestination(samaddr string, sigType ...string) (I2PKeys, error) {
+	if samaddr == "" {
+		samaddr = "127.0.0.1:7656"
+	}
+	client, err := goSam.NewClient(samaddr)
+	if err != nil {
+		return I2PKeys{}, err
+	}
+	var sigtmp string
+	if len(sigType) > 0 {
+		sigtmp = sigType[0]
+	}
+	pub, priv, err := client.NewDestination(sigtmp)
+	if err != nil {
+		return I2PKeys{}, err
+	}
+	addr, err := NewI2PAddrFromBytes([]byte(pub))
+	if err != nil {
+		return I2PKeys{}, err
+	}
+	keys := NewKeys(addr, priv+pub)
+	if err != nil {
+		return I2PKeys{}, err
+	}
+	return keys, nil
+}

i2pkeys/I2PAddr_test.go

@@ -0,0 +1,21 @@
+package i2pkeys
+
+import (
+	"fmt"
+	"testing"
+	//	"time"
+)
+
+const yoursam = "127.0.0.1:7656"
+
+func Test_Basic(t *testing.T) {
+	fmt.Println("Test_Basic")
+	fmt.Println("\tAttaching to SAM at " + yoursam)
+	keys, err := NewDestination("")
+	if err != nil {
+		fmt.Println(err.Error())
+		t.Fail()
+		return
+	}
+	fmt.Println(keys.String())
+}

primary.go

@@ -0,0 +1,377 @@
+package sam3
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/eyedeekay/sam3/i2pkeys"
+)
+
+const (
+	session_ADDOK = "SESSION STATUS RESULT=OK"
+)
+
+func randport() string {
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+	p := r.Intn(55534) + 10000
+	return strconv.Itoa(p)
+}
+
+// Represents a primary session.
+type PrimarySession struct {
+	samAddr  string          // address to the sam bridge (ipv4:port)
+	id       string          // tunnel name
+	conn     net.Conn        // connection to sam
+	keys     i2pkeys.I2PKeys // i2p destination keys
+	Timeout  time.Duration
+	Deadline time.Time
+	sigType  string
+	Config   SAMEmit
+	stsess   map[string]*StreamSession
+	dgsess   map[string]*DatagramSession
+	//	from     string
+	//	to       string
+}
+
+func (ss *PrimarySession) From() string {
+	return "0"
+}
+
+func (ss *PrimarySession) To() string {
+	return "0"
+}
+
+func (ss *PrimarySession) SignatureType() string {
+	return ss.sigType
+}
+
+// Returns the local tunnel name of the I2P tunnel used for the stream session
+func (ss *PrimarySession) ID() string {
+	return ss.id
+}
+
+func (ss *PrimarySession) Close() error {
+	return ss.conn.Close()
+}
+
+// Returns the I2P destination (the address) of the stream session
+func (ss *PrimarySession) Addr() i2pkeys.I2PAddr {
+	return ss.keys.Addr()
+}
+
+func (ss *PrimarySession) LocalAddr() net.Addr {
+	aa := ss.keys.Addr()
+	return &aa
+}
+
+// Returns the keys associated with the stream session
+func (ss *PrimarySession) Keys() i2pkeys.I2PKeys {
+	return ss.keys
+}
+
+func (sam *PrimarySession) Dial(network, addr string) (net.Conn, error) {
+	if network == "udp" || network == "udp4" || network == "udp6" {
+		return sam.DialUDPI2P(network, network+addr[0:4], addr)
+	}
+	if network == "tcp" || network == "tcp4" || network == "tcp6" {
+		return sam.DialTCPI2P(network, network+addr[0:4], addr)
+	}
+	return nil, fmt.Errorf("Error: Must specify a valid network type")
+}
+
+// DialTCP implements x/dialer
+func (sam *PrimarySession) DialTCP(network string, laddr, raddr net.Addr) (net.Conn, error) {
+	_, ok := sam.stsess[network+raddr.String()[0:4]]
+	if !ok {
+		stsess, err := sam.NewUniqueStreamSubSession(network + raddr.String()[0:4])
+		if err != nil {
+			return nil, err
+		}
+		sam.stsess[network+raddr.String()[0:4]] = stsess
+	}
+	return sam.stsess[network+raddr.String()[0:4]].Dial(network, raddr.String())
+}
+
+func (sam *PrimarySession) DialTCPI2P(network string, laddr, raddr string) (net.Conn, error) {
+	_, ok := sam.stsess[network+raddr[0:4]]
+	if !ok {
+		stsess, err := sam.NewUniqueStreamSubSession(network + laddr)
+		if err != nil {
+			return nil, err
+		}
+		sam.stsess[network+raddr[0:4]] = stsess
+	}
+	return sam.stsess[network+raddr[0:4]].Dial(network, raddr)
+}
+
+// DialUDP implements x/dialer
+func (sam *PrimarySession) DialUDP(network string, laddr, raddr net.Addr) (net.PacketConn, error) {
+	_, ok := sam.dgsess[network+raddr.String()[0:4]]
+	if !ok {
+		dgsess, err := sam.NewDatagramSubSession(network+raddr.String()[0:4], 0)
+		if err != nil {
+			return nil, err
+		}
+		sam.dgsess[network+raddr.String()[0:4]] = dgsess
+	}
+	return sam.dgsess[network+raddr.String()[0:4]].Dial(network, raddr.String())
+}
+
+func (sam *PrimarySession) DialUDPI2P(network, laddr, raddr string) (*DatagramSession, error) {
+	_, ok := sam.dgsess[network+raddr[0:4]]
+	if !ok {
+		dgsess, err := sam.NewDatagramSubSession(network+laddr, 0)
+		if err != nil {
+			return nil, err
+		}
+		sam.dgsess[network+raddr[0:4]] = dgsess
+	}
+	return sam.dgsess[network+raddr[0:4]].Dial(network, raddr)
+}
+
+func (s *PrimarySession) Lookup(name string) (a net.Addr, err error) {
+	var sam *SAM
+	if len(strings.Split(name, ":")) <= 1 {
+		name += ":0"
+	}
+	sam, err = NewSAM(s.samAddr)
+	if err == nil {
+		defer sam.Close()
+		a, err = sam.Lookup(name)
+	}
+	return
+}
+
+func (sam *PrimarySession) Resolve(network, addr string) (net.Addr, error) {
+	return sam.Lookup(addr)
+}
+
+func (sam *PrimarySession) ResolveTCPAddr(network, dest string) (net.Addr, error) {
+	return sam.Lookup(dest)
+}
+
+func (sam *PrimarySession) ResolveUDPAddr(network, dest string) (net.Addr, error) {
+	return sam.Lookup(dest)
+}
+
+// Creates a new PrimarySession with the I2CP- and streaminglib options as
+// specified. See the I2P documentation for a full list of options.
+func (sam *SAM) NewPrimarySession(id string, keys i2pkeys.I2PKeys, options []string) (*PrimarySession, error) {
+	conn, err := sam.newGenericSession("PRIMARY", id, keys, options, []string{})
+	if err != nil {
+		return nil, err
+	}
+	ssesss := make(map[string]*StreamSession)
+	dsesss := make(map[string]*DatagramSession)
+	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, sam.Config, ssesss, dsesss}, nil
+}
+
+// Creates a new PrimarySession with the I2CP- and PRIMARYinglib options as
+// specified. See the I2P documentation for a full list of options.
+func (sam *SAM) NewPrimarySessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*PrimarySession, error) {
+	conn, err := sam.newGenericSessionWithSignature("PRIMARY", id, keys, sigType, options, []string{})
+	if err != nil {
+		return nil, err
+	}
+	ssesss := make(map[string]*StreamSession)
+	dsesss := make(map[string]*DatagramSession)
+	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), sigType, sam.Config, ssesss, dsesss}, nil
+}
+
+// Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
+// for a new I2P tunnel with name id, using the cypher keys specified, with the
+// I2CP/streaminglib-options as specified. Extra arguments can be specified by
+// setting extra to something else than []string{}.
+// This sam3 instance is now a session
+func (sam *PrimarySession) newGenericSubSession(style, id string, extras []string) (net.Conn, error) {
+	return sam.newGenericSubSessionWithSignature(style, id, extras)
+}
+
+func (sam *PrimarySession) newGenericSubSessionWithSignature(style, id string, extras []string) (net.Conn, error) {
+	return sam.newGenericSubSessionWithSignatureAndPorts(style, id, "0", "0", extras)
+}
+
+// Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
+// for a new I2P tunnel with name id, using the cypher keys specified, with the
+// I2CP/streaminglib-options as specified. Extra arguments can be specified by
+// setting extra to something else than []string{}.
+// This sam3 instance is now a session
+func (sam *PrimarySession) newGenericSubSessionWithSignatureAndPorts(style, id, from, to string, extras []string) (net.Conn, error) {
+
+	conn := sam.conn
+	fp := ""
+	tp := ""
+	if from != "0" {
+		fp = " FROM_PORT=" + from
+	}
+	if to != "0" {
+		tp = " TO_PORT=" + to
+	}
+	scmsg := []byte("SESSION ADD STYLE=" + style + fp + tp + " ID=" + id + " " + strings.Join(extras, " ") + "\n")
+	for m, i := 0, 0; m != len(scmsg); i++ {
+		if i == 15 {
+			conn.Close()
+			return nil, errors.New("writing to SAM failed")
+		}
+		n, err := conn.Write(scmsg[m:])
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+		m += n
+	}
+	buf := make([]byte, 4096)
+	n, err := conn.Read(buf)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	text := string(buf[:n])
+	if strings.HasPrefix(text, session_ADDOK) {
+		//if sam.keys.String() != text[len(session_ADDOK):len(text)-1] {
+		//conn.Close()
+		//return nil, errors.New("SAMv3 created a tunnel with keys other than the ones we asked it for")
+		//}
+		return conn, nil //&StreamSession{id, conn, keys, nil, sync.RWMutex{}, nil}, nil
+	} else if text == session_DUPLICATE_ID {
+		conn.Close()
+		return nil, errors.New("Duplicate tunnel name")
+	} else if text == session_DUPLICATE_DEST {
+		conn.Close()
+		return nil, errors.New("Duplicate destination")
+	} else if text == session_INVALID_KEY {
+		conn.Close()
+		return nil, errors.New("Invalid key")
+	} else if strings.HasPrefix(text, session_I2P_ERROR) {
+		conn.Close()
+		return nil, errors.New("I2P error " + text[len(session_I2P_ERROR):])
+	} else {
+		conn.Close()
+		return nil, errors.New("Unable to parse SAMv3 reply: " + text)
+	}
+}
+
+// Creates a new StreamSession with the I2CP- and streaminglib options as
+// specified. See the I2P documentation for a full list of options.
+func (sam *PrimarySession) NewStreamSubSession(id string) (*StreamSession, error) {
+	conn, err := sam.newGenericSubSession("STREAM", id, []string{})
+	if err != nil {
+		return nil, err
+	}
+	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, "0", "0"}, nil
+}
+
+// Creates a new StreamSession with the I2CP- and streaminglib options as
+// specified. See the I2P documentation for a full list of options.
+func (sam *PrimarySession) NewUniqueStreamSubSession(id string) (*StreamSession, error) {
+	conn, err := sam.newGenericSubSession("STREAM", id, []string{})
+	if err != nil {
+		return nil, err
+	}
+	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, randport(), "0"}, nil
+}
+
+// Creates a new StreamSession with the I2CP- and streaminglib options as
+// specified. See the I2P documentation for a full list of options.
+func (sam *PrimarySession) NewStreamSubSessionWithPorts(id, from, to string) (*StreamSession, error) {
+	conn, err := sam.newGenericSubSessionWithSignatureAndPorts("STREAM", id, from, to, []string{})
+	if err != nil {
+		return nil, err
+	}
+	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, from, to}, nil
+}
+
+/*
+func (s *PrimarySession) I2PListener(name string) (*StreamListener, error) {
+	listener, err := s.NewStreamSubSession(name)
+	if err != nil {
+		return nil, err
+	}
+	return listener.Listen()
+}
+*/
+
+// Creates a new datagram session. udpPort is the UDP port SAM is listening on,
+// and if you set it to zero, it will use SAMs standard UDP port.
+func (s *PrimarySession) NewDatagramSubSession(id string, udpPort int) (*DatagramSession, error) {
+	if udpPort > 65335 || udpPort < 0 {
+		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
+	}
+	if udpPort == 0 {
+		udpPort = 7655
+	}
+	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
+	if err != nil {
+		s.Close()
+		return nil, err
+	}
+	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
+	if err != nil {
+		return nil, err
+	}
+	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
+	if err != nil {
+		return nil, err
+	}
+	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		s.Close()
+		return nil, err
+	}
+	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
+	if err != nil {
+		return nil, err
+	}
+	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
+	conn, err := s.newGenericSubSession("DATAGRAM", id, []string{"PORT=" + lport})
+	if err != nil {
+		return nil, err
+	}
+	return &DatagramSession{s.Config.I2PConfig.Sam(), id, conn, udpconn, s.keys, rUDPAddr, nil}, nil
+}
+
+// Creates a new raw session. udpPort is the UDP port SAM is listening on,
+// and if you set it to zero, it will use SAMs standard UDP port.
+func (s *PrimarySession) NewRawSubSession(id string, udpPort int) (*RawSession, error) {
+	if udpPort > 65335 || udpPort < 0 {
+		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
+	}
+	if udpPort == 0 {
+		udpPort = 7655
+	}
+	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
+	if err != nil {
+		s.Close()
+		return nil, err
+	}
+	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
+	if err != nil {
+		return nil, err
+	}
+	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
+	if err != nil {
+		return nil, err
+	}
+	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		s.Close()
+		return nil, err
+	}
+	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
+	if err != nil {
+		return nil, err
+	}
+	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
+	//	conn, err := s.newGenericSubSession("RAW", id, s.keys, options, []string{"PORT=" + lport})
+	conn, err := s.newGenericSubSession("RAW", id, []string{"PORT=" + lport})
+	if err != nil {
+		return nil, err
+	}
+	return &RawSession{s.Config.I2PConfig.Sam(), id, conn, udpconn, s.keys, rUDPAddr}, nil
+}

primary_datagram_test.go

@@ -0,0 +1,151 @@
+// +build nettest
+
+package sam3
+
+import (
+	"fmt"
+	"log"
+	"testing"
+	"time"
+)
+
+func Test_PrimaryDatagramServerClient(t *testing.T) {
+	if testing.Short() {
+		return
+	}
+
+	fmt.Println("Test_PrimaryDatagramServerClient")
+	earlysam, err := NewSAM(yoursam)
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		t.Fail()
+		return
+	}
+
+	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer sam.Close()
+	//	fmt.Println("\tServer: My address: " + keys.Addr().Base32())
+	fmt.Println("\tServer: Creating tunnel")
+	ds, err := sam.NewDatagramSubSession("PrimaryTunnel"+RandString(), 0)
+	if err != nil {
+		fmt.Println("Server: Failed to create tunnel: " + err.Error())
+		t.Fail()
+		return
+	}
+	defer ds.Close()
+	c, w := make(chan bool), make(chan bool)
+	go func(c, w chan (bool)) {
+		sam2, err := NewSAM(yoursam)
+		if err != nil {
+			c <- false
+			return
+		}
+		defer sam2.Close()
+		keys, err := sam2.NewKeys()
+		if err != nil {
+			c <- false
+			return
+		}
+		fmt.Println("\tClient: Creating tunnel")
+		ds2, err := sam2.NewDatagramSession("PRIMARYClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
+		if err != nil {
+			c <- false
+			return
+		}
+		defer ds2.Close()
+		//		fmt.Println("\tClient: Servers address: " + ds.LocalAddr().Base32())
+		//		fmt.Println("\tClient: Clients address: " + ds2.LocalAddr().Base32())
+		fmt.Println("\tClient: Tries to send primary to server")
+		for {
+			select {
+			default:
+				_, err = ds2.WriteTo([]byte("Hello primary-world! <3 <3 <3 <3 <3 <3"), ds.LocalAddr())
+				if err != nil {
+					fmt.Println("\tClient: Failed to send primary: " + err.Error())
+					c <- false
+					return
+				}
+				time.Sleep(5 * time.Second)
+			case <-w:
+				fmt.Println("\tClient: Sent primary, quitting.")
+				return
+			}
+		}
+		c <- true
+	}(c, w)
+	buf := make([]byte, 512)
+	fmt.Println("\tServer: ReadFrom() waiting...")
+	n, _, err := ds.ReadFrom(buf)
+	w <- true
+	if err != nil {
+		fmt.Println("\tServer: Failed to ReadFrom(): " + err.Error())
+		t.Fail()
+		return
+	}
+	fmt.Println("\tServer: Received primary: " + string(buf[:n]))
+	//	fmt.Println("\tServer: Senders address was: " + saddr.Base32())
+}
+
+func ExamplePrimaryDatagramSession() {
+	// Creates a new PrimarySession, then creates a Datagram subsession on top of it
+
+	const samBridge = "127.0.0.1:7656"
+
+	earlysam, err := NewSAM(samBridge)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	myself := keys.Addr()
+
+	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer sam.Close()
+
+	// See the example Option_* variables.
+	dg, err := sam.NewDatagramSubSession("DGTUN"+RandString(), 0)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer dg.Close()
+	someone, err := earlysam.Lookup("zzz.i2p")
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+
+	dg.WriteTo([]byte("Hello stranger!"), someone)
+	dg.WriteTo([]byte("Hello myself!"), myself)
+
+	buf := make([]byte, 31*1024)
+	n, _, err := dg.ReadFrom(buf)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	log.Println("Got message: '" + string(buf[:n]) + "'")
+	fmt.Println("Got message: " + string(buf[:n]))
+
+	return
+	// Output:
+	//Got message: Hello myself!
+}

primary_stream_test.go

@@ -0,0 +1,309 @@
+// +build nettest
+
+package sam3
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/eyedeekay/sam3/i2pkeys"
+)
+
+func Test_PrimaryStreamingDial(t *testing.T) {
+	if testing.Short() {
+		return
+	}
+	fmt.Println("Test_PrimaryStreamingDial")
+	earlysam, err := NewSAM(yoursam)
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		t.Fail()
+		return
+	}
+
+	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer sam.Close()
+	fmt.Println("\tBuilding tunnel")
+	ss, err := sam.NewStreamSubSession("primaryStreamTunnel")
+	if err != nil {
+		fmt.Println(err.Error())
+		t.Fail()
+		return
+	}
+	defer ss.Close()
+	fmt.Println("\tNotice: This may fail if your I2P node is not well integrated in the I2P network.")
+	fmt.Println("\tLooking up i2p-projekt.i2p")
+	forumAddr, err := earlysam.Lookup("i2p-projekt.i2p")
+	if err != nil {
+		fmt.Println(err.Error())
+		t.Fail()
+		return
+	}
+	fmt.Println("\tDialing i2p-projekt.i2p(", forumAddr.Base32(), forumAddr.DestHash().Hash(), ")")
+	conn, err := ss.DialI2P(forumAddr)
+	if err != nil {
+		fmt.Println(err.Error())
+		t.Fail()
+		return
+	}
+	defer conn.Close()
+	fmt.Println("\tSending HTTP GET /")
+	if _, err := conn.Write([]byte("GET /\n")); err != nil {
+		fmt.Println(err.Error())
+		t.Fail()
+		return
+	}
+	buf := make([]byte, 4096)
+	n, err := conn.Read(buf)
+	if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
+		fmt.Printf("\tProbably failed to StreamSession.DialI2P(i2p-projekt.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
+	} else {
+		fmt.Println("\tRead HTTP/HTML from i2p-projekt.i2p")
+	}
+}
+
+func Test_PrimaryStreamingServerClient(t *testing.T) {
+	if testing.Short() {
+		return
+	}
+
+	fmt.Println("Test_StreamingServerClient")
+	earlysam, err := NewSAM(yoursam)
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		t.Fail()
+		return
+	}
+
+	sam, err := earlysam.NewPrimarySession("PrimaryServerClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		t.Fail()
+		return
+	}
+	defer sam.Close()
+	fmt.Println("\tServer: Creating tunnel")
+	ss, err := sam.NewUniqueStreamSubSession("primaryExampleServerTun")
+	if err != nil {
+		return
+	}
+	defer ss.Close()
+	time.Sleep(time.Second * 10)
+	c, w := make(chan bool), make(chan bool)
+	go func(c, w chan (bool)) {
+		if !(<-w) {
+			return
+		}
+		/*sam2, err := NewSAM(yoursam)
+		if err != nil {
+			c <- false
+			return
+		}
+		defer sam2.Close()
+		keys, err := sam2.NewKeys()
+		if err != nil {
+			c <- false
+			return
+		}*/
+		fmt.Println("\tClient: Creating tunnel")
+		ss2, err := sam.NewStreamSubSession("primaryExampleClientTun")
+		if err != nil {
+			c <- false
+			return
+		}
+		defer ss2.Close()
+		fmt.Println("\tClient: Connecting to server")
+		conn, err := ss2.DialI2P(ss.Addr())
+		if err != nil {
+			c <- false
+			return
+		}
+		fmt.Println("\tClient: Connected to tunnel")
+		defer conn.Close()
+		_, err = conn.Write([]byte("Hello world <3 <3 <3 <3 <3 <3"))
+		if err != nil {
+			c <- false
+			return
+		}
+		c <- true
+	}(c, w)
+	l, err := ss.Listen()
+	if err != nil {
+		fmt.Println("ss.Listen(): " + err.Error())
+		t.Fail()
+		w <- false
+		return
+	}
+	defer l.Close()
+	w <- true
+	fmt.Println("\tServer: Accept()ing on tunnel")
+	conn, err := l.Accept()
+	if err != nil {
+		t.Fail()
+		fmt.Println("Failed to Accept(): " + err.Error())
+		return
+	}
+	defer conn.Close()
+	buf := make([]byte, 512)
+	n, err := conn.Read(buf)
+	fmt.Printf("\tClient exited successfully: %t\n", <-c)
+	fmt.Println("\tServer: received from Client: " + string(buf[:n]))
+}
+
+func ExamplePrimaryStreamSession() {
+	// Creates a new StreamingSession, dials to idk.i2p and gets a SAMConn
+	// which behaves just like a normal net.Conn.
+
+	const samBridge = "127.0.0.1:7656"
+
+	earlysam, err := NewSAM(yoursam)
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+
+	sam, err := earlysam.NewPrimarySession("PrimaryServerClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+	defer sam.Close()
+	// See the example Option_* variables.
+	ss, err := sam.NewStreamSubSession("stream_example")
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	ss.Close()
+	someone, err := earlysam.Lookup("idk.i2p")
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+
+	conn, err := ss.DialI2P(someone)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer conn.Close()
+	fmt.Println("Sending HTTP GET /")
+	if _, err := conn.Write([]byte("GET /\n")); err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	buf := make([]byte, 4096)
+	n, err := conn.Read(buf)
+	if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
+		fmt.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
+		log.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
+	} else {
+		fmt.Println("Read HTTP/HTML from idk.i2p")
+		log.Println("Read HTTP/HTML from idk.i2p")
+	}
+	return
+
+	// Output:
+	//Sending HTTP GET /
+	//Read HTTP/HTML from idk.i2p
+}
+
+func ExamplePrimaryStreamListener() {
+	// One server Accept()ing on a StreamListener, and one client that Dials
+	// through I2P to the server. Server writes "Hello world!" through a SAMConn
+	// (which implements net.Conn) and the client prints the message.
+
+	const samBridge = "127.0.0.1:7656"
+
+	earlysam, err := NewSAM(yoursam)
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+	defer earlysam.Close()
+	keys, err := earlysam.NewKeys()
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+
+	sam, err := earlysam.NewPrimarySession("PrimaryListenerTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	if err != nil {
+		log.Fatal(err.Error())
+		return
+	}
+	defer sam.Close()
+
+	quit := make(chan bool)
+
+	// Client connecting to the server
+	go func(server i2pkeys.I2PAddr) {
+		cs, err := sam.NewStreamSubSession("client_example")
+		if err != nil {
+			fmt.Println(err.Error())
+			quit <- false
+			return
+		}
+		defer cs.Close()
+		conn, err := cs.DialI2P(server)
+		if err != nil {
+			fmt.Println(err.Error())
+			quit <- false
+			return
+		}
+		buf := make([]byte, 256)
+		n, err := conn.Read(buf)
+		if err != nil {
+			fmt.Println(err.Error())
+			quit <- false
+			return
+		}
+		fmt.Println(string(buf[:n]))
+		quit <- true
+	}(keys.Addr()) // end of client
+
+	ss, err := sam.NewStreamSubSession("server_example")
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer ss.Close()
+	l, err := ss.Listen()
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	conn, err := l.Accept()
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	conn.Write([]byte("Hello world!"))
+
+	<-quit // waits for client to die, for example only
+
+	// Output:
+	//Hello world!
+}

sam3.go

@@ -6,6 +6,7 @@ import (
 	"bytes"
 	"errors"
 	"io"
+	"math/rand"
 	"net"
 	"os"
 	"strings"
@@ -44,6 +45,17 @@ const (
 	Sig_EdDSA_SHA512_Ed25519 = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
 )
 
+var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+
+func RandString() string {
+	n := 4
+	b := make([]rune, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}
+
 // Creates a new controller for the I2P routers SAM bridge.
 func NewSAM(address string) (*SAM, error) {
 	var s SAM
@@ -205,7 +217,15 @@ func (sam *SAM) newGenericSessionWithSignatureAndPorts(style, id, from, to strin
 	}
 
 	conn := sam.conn
-	scmsg := []byte("SESSION CREATE STYLE=" + style + " FROM_PORT=" + from + " TO_PORT=" + to + " ID=" + id + " DESTINATION=" + keys.String() + " " + sigType + " " + optStr + strings.Join(extras, " ") + "\n")
+	fp := ""
+	tp := ""
+	if from != "0" {
+		fp = " FROM_PORT=" + from
+	}
+	if to != "0" {
+		tp = " TO_PORT=" + to
+	}
+	scmsg := []byte("SESSION CREATE STYLE=" + style + fp + tp + " ID=" + id + " DESTINATION=" + keys.String() + " " + optStr + strings.Join(extras, " ") + "\n")
 	for m, i := 0, 0; m != len(scmsg); i++ {
 		if i == 15 {
 			conn.Close()

stream.go

@@ -28,6 +28,18 @@ type StreamSession struct {
 	to       string
 }
 
+func (s *StreamSession) SetDeadline(t time.Time) error {
+	return s.conn.SetDeadline(t)
+}
+
+func (s *StreamSession) SetReadDeadline(t time.Time) error {
+	return s.conn.SetReadDeadline(t)
+}
+
+func (s *StreamSession) SetWriteDeadline(t time.Time) error {
+	return s.conn.SetWriteDeadline(t)
+}
+
 func (ss *StreamSession) From() string {
 	return ss.from
 }
@@ -54,6 +66,10 @@ func (ss *StreamSession) Addr() i2pkeys.I2PAddr {
 	return ss.keys.Addr()
 }
 
+func (ss *StreamSession) LocalAddr() net.Addr {
+	return ss.keys.Addr()
+}
+
 // Returns the keys associated with the stream session
 func (ss *StreamSession) Keys() i2pkeys.I2PKeys {
 	return ss.keys

suggestedOptions.go

@@ -10,17 +10,30 @@ var (
 		"inbound.quantity=6", "outbound.quantity=6"}
 
 	// Suitable for shuffling a lot of traffic.
-	Options_Fat = []string{"inbound.length=3", "outbound.length=3",
+	Options_Large = []string{"inbound.length=3", "outbound.length=3",
 		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
 		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
 		"inbound.quantity=4", "outbound.quantity=4"}
 
+	// Suitable for shuffling a lot of traffic quickly with minimum
+	// anonymity. Uses 1 hop and multiple tunnels.
+	Options_Wide = []string{"inbound.length=1", "outbound.length=1",
+		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
+		"inbound.backupQuantity=2", "outbound.backupQuantity=2",
+		"inbound.quantity=3", "outbound.quantity=3"}
+
 	// Suitable for shuffling medium amounts of traffic.
 	Options_Medium = []string{"inbound.length=3", "outbound.length=3",
 		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
 		"inbound.backupQuantity=0", "outbound.backupQuantity=0",
 		"inbound.quantity=2", "outbound.quantity=2"}
 
+	// Sensible defaults for most people
+	Options_Default = []string{"inbound.length=3", "outbound.length=3",
+		"inbound.lengthVariance=0", "outbound.lengthVariance=0",
+		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
+		"inbound.quantity=1", "outbound.quantity=1"}
+
 	// Suitable only for small dataflows, and very short lasting connections:
 	// You only have one tunnel in each direction, so if any of the nodes
 	// through which any of your two tunnels pass through go offline, there will