diff --git a/go.mod b/go.mod index 90e14b2..f1c3ad3 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,11 @@ module github.com/go-i2p/go-i2p go 1.16 require ( + github.com/dchest/siphash v1.2.3 // indirect github.com/emirpasic/gods v1.18.1 + github.com/flynn/noise v1.0.0 + github.com/go-noisesocket/noisesocket v0.0.0-20191014121341-f487ac765620 + github.com/pkg/errors v0.9.1 // indirect github.com/sirupsen/logrus v1.9.0 github.com/stretchr/testify v1.7.0 golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa diff --git a/go.sum b/go.sum index 46b7fad..c2f6282 100644 --- a/go.sum +++ b/go.sum @@ -1,26 +1,33 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA= +github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc= github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/flynn/noise v1.0.0 h1:DlTHqmzmvcEiKj+4RYo/imoswx/4r6iBlCMfVtrMXpQ= +github.com/flynn/noise v1.0.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag= +github.com/go-noisesocket/noisesocket v0.0.0-20191014121341-f487ac765620 h1:MjTFQi2DyJifqefRVjAs+P2gaoUAj2rcDpYX7ERggEA= +github.com/go-noisesocket/noisesocket v0.0.0-20191014121341-f487ac765620/go.mod h1:y9SBFk2hEIPWY7Aj3bXG+K1xp8wWnQ6kVq2wsYSPByU= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE= -github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -golang.org/x/crypto v0.0.0-20210415154028-4f45737414dc h1:+q90ECDSAQirdykUN6sPEiBXBsp8Csjcca8Oy7bgLTA= -golang.org/x/crypto v0.0.0-20210415154028-4f45737414dc/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa h1:zuSxTR4o9y82ebqCUJYNGJbGPo6sKVl54f/TVDObg1c= golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -31,7 +38,8 @@ golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9sn golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/lib/common/data/mapping_test.go b/lib/common/data/mapping_test.go index 2253428..986d2bd 100644 --- a/lib/common/data/mapping_test.go +++ b/lib/common/data/mapping_test.go @@ -115,6 +115,14 @@ func TestHasDuplicateKeysFalseWithoutDuplicates(t *testing.T) { assert.Equal(false, mapping.HasDuplicateKeys(), "HasDuplicateKeys() did not report false when no duplicate keys present") } +func TestReadMappingHasDuplicateKeys(t *testing.T) { + assert := assert.New(t) + + _, _, errs := NewMapping([]byte{0x00, 0x0c, 0x01, 0x61, 0x3d, 0x01, 0x62, 0x3b, 0x01, 0x61, 0x3d, 0x01, 0x62, 0x3b}) + + assert.Equal("mapping format violation, duplicate key in mapping", errs[0].Error(), "ReadMapping should throw an error when duplicate keys are present.") +} + func TestGoMapToMappingProducesCorrectMapping(t *testing.T) { assert := assert.New(t) diff --git a/lib/common/data/mapping_values.go b/lib/common/data/mapping_values.go index fbc041c..4e46b0e 100644 --- a/lib/common/data/mapping_values.go +++ b/lib/common/data/mapping_values.go @@ -30,37 +30,17 @@ func ValuesToMapping(values MappingValues) *Mapping { } } -type byValue MappingValues - -func (set byValue) Len() int { return len(set) } -func (set byValue) Swap(i, j int) { set[i], set[j] = set[j], set[i] } -func (set byValue) Less(i, j int) bool { - data1, _ := set[i][1].Data() - data2, _ := set[j][1].Data() - return data1 < data2 -} - -type byKey MappingValues - -func (set byKey) Len() int { return len(set) } -func (set byKey) Swap(i, j int) { set[i], set[j] = set[j], set[i] } -func (set byKey) Less(i, j int) bool { - data1, _ := set[i][0].Data() - data2, _ := set[j][0].Data() - return data1 < data2 -} - -// -// I2P Mappings require consistent order for for cryptographic signing, and sorting -// by keys. When new Mappings are created, they are stable sorted first by values -// than by keys to ensure a consistent order. -// - -// TODO: This sort doesn't appear to work the same as ref implementation. -// It also appears to be unstable +// I2P Mappings require consistent order in some cases for cryptographic signing, and sorting +// by keys. The Mapping is sorted lexographically by keys. Duplicate keys are allowed in general, +// but in implementations where they must be sorted like I2CP SessionConfig duplicate keys are not allowed. +// In practice routers do not seem to allow duplicate keys. func mappingOrder(values MappingValues) { - sort.Stable(byValue(values)) - sort.Stable(byKey(values)) + sort.SliceStable(values, func(i, j int) bool { + // Lexographic sort on keys only + data1, _ := values[i][0].Data() + data2, _ := values[j][0].Data() + return data1 < data2 + }) } // ReadMappingValues returns *MappingValues from a []byte. @@ -109,6 +89,7 @@ func ReadMappingValues(remainder []byte) (values *MappingValues, remainder_bytes errs = append(errs, errors.New("warning parsing mapping: mapping length exceeds provided data")) } + encounteredKeysMap := map[string]bool{} // pop off length bytes before parsing kv pairs remainder = remainder[2:] @@ -140,6 +121,23 @@ func ReadMappingValues(remainder []byte) (values *MappingValues, remainder_bytes //return } } + + // Check if key has already been encountered in this mapping + keyBytes, _ := key_str.Data() + keyAsString := string(keyBytes) + _, ok := encounteredKeysMap[keyAsString] + if ok { + log.WithFields(log.Fields{ + "at": "(Mapping) Values", + "reason": "duplicate key in mapping", + }).Error("mapping format violation") + errs = append(errs, errors.New("mapping format violation, duplicate key in mapping")) + // Based on other implementations this does not seem to happen often? + // Java throws an exception in this case, the base object is a Hashmap so the value is overwritten and an exception is thrown. + // i2pd as far as I can tell just overwrites the original value + // Continue on, we can check if the Mapping contains duplicate keys later. + } + if !beginsWith(remainder, 0x3d) { log.WithFields(log.Fields{ "at": "(Mapping) Values", @@ -177,6 +175,9 @@ func ReadMappingValues(remainder []byte) (values *MappingValues, remainder_bytes if len(remainder) == 0 { break } + + // Store the encountered key with arbitrary data + encounteredKeysMap[keyAsString] = true } values = &map_values return diff --git a/lib/common/data/mapping_values_test.go b/lib/common/data/mapping_values_test.go index ae5c868..a1e6e2b 100644 --- a/lib/common/data/mapping_values_test.go +++ b/lib/common/data/mapping_values_test.go @@ -1,38 +1,46 @@ package data import ( + "fmt" "testing" ) func TestMappingOrderSortsValuesThenKeys(t *testing.T) { a, _ := ToI2PString("a") b, _ := ToI2PString("b") + aa, _ := ToI2PString("aa") + ab, _ := ToI2PString("ab") + ac, _ := ToI2PString("ac") values := MappingValues{ [2]I2PString{b, b}, - [2]I2PString{b, a}, - [2]I2PString{a, b}, + [2]I2PString{ac, a}, + [2]I2PString{ab, b}, + [2]I2PString{aa, a}, [2]I2PString{a, a}, } mappingOrder(values) for i, pair := range values { key, _ := pair[0].Data() - value, _ := pair[1].Data() switch i { case 0: - if !(key == "a" && value == "a") { - t.Fatal("mappingOrder produced incorrect sort output at", i) + if !(key == "a") { + t.Fatal(fmt.Sprintf("mappingOrder expected key a, got %s at index", key), i) } case 1: - if !(key == "a" && value == "b") { - t.Fatal("mappingOrder produced incorrect sort output at", i) + if !(key == "aa") { + t.Fatal(fmt.Sprintf("mappingOrder expected key aa, got %s at index", key), i) } case 2: - if !(key == "b" && value == "a") { - t.Fatal("mappingOrder produced incorrect sort output at", i) + if !(key == "ab") { + t.Fatal(fmt.Sprintf("mappingOrder expected key ab, got %s at index", key), i) } case 3: - if !(key == "b" && value == "b") { - t.Fatal("mappingOrder produced incorrect sort output at", i) + if !(key == "ac") { + t.Fatal(fmt.Sprintf("mappingOrder expected key ac, got %s at index", key), i) + } + case 4: + if !(key == "b") { + t.Fatal(fmt.Sprintf("mappingOrder expected key b, got %s at index", key), i) } } } diff --git a/lib/transport/noise/client_handshake.go b/lib/transport/noise/client_handshake.go new file mode 100644 index 0000000..8d664bd --- /dev/null +++ b/lib/transport/noise/client_handshake.go @@ -0,0 +1,123 @@ +package noise + +import ( + "bytes" + "crypto/rand" + "encoding/binary" + "errors" + "io" + + "github.com/flynn/noise" +) + +func ComposeInitiatorHandshakeMessage(s noise.DHKey, rs []byte, payload []byte, ePrivate []byte) (negData, msg []byte, state *noise.HandshakeState, err error) { + if len(rs) != 0 && len(rs) != noise.DH25519.DHLen() { + + return nil, nil, nil, errors.New("only 32 byte curve25519 public keys are supported") + + } + var pattern noise.HandshakePattern + negData = make([]byte, 6) + copy(negData, negotiationData) + pattern = noise.HandshakeIK + negData[5] = NOISE_PATTERN_IK + var random io.Reader + if len(ePrivate) == 0 { + random = rand.Reader + } else { + random = bytes.NewBuffer(ePrivate) + } + prologue := make([]byte, 2, uint16Size+len(negData)) + binary.BigEndian.PutUint16(prologue, uint16(len(negData))) + prologue = append(prologue, negData...) + prologue = append(initString, prologue...) + state, err = noise.NewHandshakeState(noise.Config{ + StaticKeypair: s, + Initiator: true, + Pattern: pattern, + CipherSuite: noise.NewCipherSuite(noise.DH25519, noise.CipherAESGCM, noise.HashBLAKE2b), + PeerStatic: rs, + Prologue: prologue, + Random: random, + }) + if err != nil { + return + } + padBuf := make([]byte, 2+len(payload)) + copy(padBuf[2:], payload) + msg, _, _, err = state.WriteMessage(msg, padBuf) + return +} + +func (c *NoiseSession) RunClientHandshake() error { + var ( + negData, msg []byte + state *noise.HandshakeState + err error + ) + if negData, msg, state, err = ComposeInitiatorHandshakeMessage(c.StaticKey, nil, nil, nil); err != nil { + return err + } + if _, err = c.Write(negData); err != nil { + return err + } + if _, err = c.Write(msg); err != nil { + return err + } + //read negotiation data + /*if err := c.readPacket(); err != nil { + return err + } + negotiationData := c.handshakeBuffer.Next(c.handshakeBuffer.Len()) + //read noise message + if err := c.readPacket(); err != nil { + return err + } + msg = c.handshakeBuffer.Next(c.handshakeBuffer.Len()) + if len(negotiationData) != 0 || len(msg) == 0 { + return errors.New("Server returned error") + } + // cannot reuse msg for read, need another buf + inBlock := c.NoiseTransport.newBlock() + inBlock.reserve(len(msg))*/ + var payload int + payload, c.CipherState, c.NoiseTransport.CipherState, err = state.ReadMessage(inBlock.data, msg) + /*if err != nil { + c.NoiseTransport.freeBlock(inBlock) + return err + }*/ + err = c.processCallback(state.PeerStatic(), payload) + if err != nil { + c.NoiseTransport.freeBlock(inBlock) + return err + } + /*c.NoiseTransport.freeBlock(inBlock) + if c.CipherState == nil && c.NoiseTransport.CipherState == nil { + b := c.newBlock() + if b.data, c.CipherState, c.NoiseTransport.CipherState, err = state.WriteMessage(b.data, pad(c.config.Payload)); err != nil { + c.freeBlock(b) + return err + } + if _, err = c.Write(nil); err != nil { + c.freeBlock(b) + return err + } + if _, err = c.Write(b.data); err != nil { + c.freeBlock(b) + return err + } + c.freeBlock(b) + if c.CipherState == nil || c.NoiseTransport.CipherState == nil { + log.WithFields(log.Fields{ + "at": "(NoiseSession) RunClientHandshake", + "reason": "unsupported session", + }).Error("unsupported session") + return errors.New("unsupported session") + } + } + */ + //c.in.padding, c.out.padding = c.config.Padding, c.config.Padding + //c.channelBinding = state.ChannelBinding() + c.handshakeComplete = true + return nil +} diff --git a/lib/transport/noise/client_session.go b/lib/transport/noise/client_session.go new file mode 100644 index 0000000..6799b3f --- /dev/null +++ b/lib/transport/noise/client_session.go @@ -0,0 +1,75 @@ +package noise + +import ( + "errors" + "sync/atomic" + + log "github.com/sirupsen/logrus" +) + +func (c *NoiseSession) Write(b []byte) (int, error) { + // interlock with Close below + for { + x := atomic.LoadInt32(&c.activeCall) + if x&1 != 0 { + log.WithFields(log.Fields{ + "at": "(NoiseSession) Write", + "reason": "session is closed", + }).Error("session is closed") + return 0, errors.New("session is closed") + } + if atomic.CompareAndSwapInt32(&c.activeCall, x, x+2) { + defer atomic.AddInt32(&c.activeCall, -2) + break + } + } + if err := c.RunClientHandshake(); err != nil { + return 0, err + } + c.Mutex.Lock() + defer c.Mutex.Unlock() + if !c.handshakeComplete { + return 0, errors.New("internal error") + } + n, err := c.writePacketLocked(b) + return n, err +} + +func (c *NoiseSession) writePacketLocked(data []byte) (int, error) { + var n int + if len(data) == 0 { //special case to answer when everything is ok during handshake + if _, err := c.Conn.Write(make([]byte, 2)); err != nil { + return 0, err + } + } + for len(data) > 0 { + /*m := len(data) + packet := c.InitializePacket() + maxPayloadSize := c.maxPayloadSizeForWrite(packet) + if m > int(maxPayloadSize) { + m = int(maxPayloadSize) + } + if c.CipherState != nil { + ////fmt.Println("writing encrypted packet:", m) + packet.reserve(uint16Size + uint16Size + m + macSize) + packet.resize(uint16Size + uint16Size + m) + copy(packet.data[uint16Size+uint16Size:], data[:m]) + binary.BigEndian.PutUint16(packet.data[uint16Size:], uint16(m)) + //fmt.Println("encrypt size", uint16(m)) + } else { + packet.resize(len(packet.data) + len(data)) + copy(packet.data[uint16Size:len(packet.data)], data[:m]) + binary.BigEndian.PutUint16(packet.data, uint16(len(data))) + } + b := c.encryptIfNeeded(packet) + c.freeBlock(packet) + ////fmt.Println(hex.EncodeToString(b)) + if _, err := c.conn.Write(b); err != nil { + return n, err + } + n += m + data = data[m:] + */ + } + return n, nil +} diff --git a/lib/transport/noise/handshake.go b/lib/transport/noise/handshake.go new file mode 100644 index 0000000..59cc91a --- /dev/null +++ b/lib/transport/noise/handshake.go @@ -0,0 +1,41 @@ +package noise + +import ( + "sync" + + "github.com/go-i2p/go-i2p/lib/common/router_info" +) + +func (c *NoiseTransport) Handshake(routerInfo router_info.RouterInfo) error { + c.Mutex.Lock() + defer c.Mutex.Unlock() + session, err := c.GetSession(routerInfo) + if err != nil { + return err + } + for { + if session.(*NoiseSession).handshakeComplete { + return nil + } + if session.(*NoiseSession).Cond == nil { + break + } + session.(*NoiseSession).Cond.Wait() + } + // Set handshakeCond to indicate that this goroutine is committing to + // running the handshake. + session.(*NoiseSession).Cond = sync.NewCond(&c.Mutex) + c.Mutex.Unlock() + session.(*NoiseSession).Mutex.Lock() + defer session.(*NoiseSession).Mutex.Unlock() + c.Mutex.Lock() + // if c.config.isClient { + if err := session.(*NoiseSession).RunClientHandshake(); err != nil { + return err + } + // Wake any other goroutines that are waiting for this handshake to + // complete. + session.(*NoiseSession).Cond.Broadcast() + session.(*NoiseSession).Cond = nil + return nil +} diff --git a/lib/transport/noise/session.go b/lib/transport/noise/session.go index 83581ef..2088633 100644 --- a/lib/transport/noise/session.go +++ b/lib/transport/noise/session.go @@ -1,10 +1,14 @@ package noise import ( + "bytes" "fmt" "net" + "sync" + "time" cb "github.com/emirpasic/gods/queues/circularbuffer" + "github.com/flynn/noise" log "github.com/sirupsen/logrus" "github.com/go-i2p/go-i2p/lib/common/router_info" @@ -15,10 +19,47 @@ import ( type NoiseSession struct { *cb.Queue router_info.RouterInfo - net.Conn + *noise.CipherState + sync.Mutex + *sync.Cond + *NoiseTransport + handshakeBuffer bytes.Buffer + activeCall int32 + handshakeComplete bool + Conn net.Conn +} + +// Read implements net.Conn +func (*NoiseSession) Read(b []byte) (n int, err error) { + panic("unimplemented") +} + +// RemoteAddr implements net.Conn +func (*NoiseSession) RemoteAddr() net.Addr { + panic("unimplemented") +} + +// SetDeadline implements net.Conn +func (*NoiseSession) SetDeadline(t time.Time) error { + panic("unimplemented") +} + +// SetReadDeadline implements net.Conn +func (*NoiseSession) SetReadDeadline(t time.Time) error { + panic("unimplemented") +} + +// SetWriteDeadline implements net.Conn +func (*NoiseSession) SetWriteDeadline(t time.Time) error { + panic("unimplemented") } var exampleNoiseSession transport.TransportSession = &NoiseSession{} +var ExampleNoiseSession net.Conn = exampleNoiseSession.(*NoiseSession) + +func (s *NoiseSession) LocalAddr() net.Addr { + return s.Conn.LocalAddr() +} func (s *NoiseSession) QueueSendI2NP(msg i2np.I2NPMessage) { s.Queue.Enqueue(msg) diff --git a/lib/transport/noise/transport.go b/lib/transport/noise/transport.go index a0cb7ee..33203ac 100644 --- a/lib/transport/noise/transport.go +++ b/lib/transport/noise/transport.go @@ -8,9 +8,10 @@ package noise import ( "errors" - "fmt" "net" + "sync" + "github.com/flynn/noise" "github.com/go-i2p/go-i2p/lib/common/data" "github.com/go-i2p/go-i2p/lib/common/router_identity" "github.com/go-i2p/go-i2p/lib/common/router_info" @@ -19,13 +20,32 @@ import ( ) type NoiseTransport struct { - routerIdentity router_identity.RouterIdentity + *noise.CipherState + router_identity.RouterIdentity + sync.Mutex + Listener net.Listener peerConnections map[data.Hash]transport.TransportSession +<<<<<<< HEAD netSocket net.Listener +======= +>>>>>>> 8d631239b7559bf5f65b5e1e6872219d156efa8b } var exampleNoiseTransport transport.Transport = &NoiseTransport{} +// ExampleNoiseListener is not a real Noise Listener, do not use it. +// It is exported so that it can be confirmed that the transport +// implements net.Listener +var ExampleNoiseListener net.Listener = exampleNoiseTransport + +func (noopt *NoiseTransport) Accept() (net.Conn, error) { + return noopt.Listener.Accept() +} + +func (noopt *NoiseTransport) Addr() net.Addr { + return noopt.Listener.Addr() +} + func (noopt *NoiseTransport) Name() string { return "noise" } @@ -52,7 +72,6 @@ func (noopt *NoiseTransport) SetIdentity(ident router_identity.RouterIdentity) ( // returns an established TransportSession and nil on success // returns nil and an error on error func (noopt *NoiseTransport) GetSession(routerInfo router_info.RouterInfo) (transport.TransportSession, error) { - var err error hash := routerInfo.IdentHash() if len(hash) == 0 { return nil, errors.New("NoiseTransport: GetSession: RouterInfo has no IdentityHash") @@ -60,10 +79,13 @@ func (noopt *NoiseTransport) GetSession(routerInfo router_info.RouterInfo) (tran if t, ok := noopt.peerConnections[hash]; ok { return t, nil } - if noopt.peerConnections[hash], err = NewNoiseTransportSession(routerInfo); err != nil { - return noopt.peerConnections[hash], err + conn, err := noopt.Accept() + if err == nil { + if noopt.peerConnections[hash], err = NewNoiseTransportSession(routerInfo, conn); err != nil { + return noopt.peerConnections[hash], err + } } - return nil, fmt.Errorf("Unable to obtain transport session with %s", routerInfo.IdentHash()) + return nil, err } // Compatable return true if a routerInfo is compatable with this transport @@ -83,7 +105,7 @@ func (noopt *NoiseTransport) Close() error { func NewNoiseTransport(netSocket net.Listener) *NoiseTransport { return &NoiseTransport{ peerConnections: make(map[data.Hash]transport.TransportSession), - netSocket: netSocket, + Listener: netSocket, } } diff --git a/lib/transport/transport.go b/lib/transport/transport.go index bdd2c8a..79321f7 100644 --- a/lib/transport/transport.go +++ b/lib/transport/transport.go @@ -1,6 +1,8 @@ package transport import ( + "net" + "github.com/go-i2p/go-i2p/lib/common/router_identity" "github.com/go-i2p/go-i2p/lib/common/router_info" @@ -23,6 +25,11 @@ type TransportSession interface { } type Transport interface { + // Accept accepts an incoming session. + Accept() (net.Conn, error) + + // Addr returns an + Addr() net.Addr // Set the router identity for this transport. // will bind if the underlying socket is not already