June 2016 - tor-commits - lists.torproject.org

[tor/master] typo/comment/log fixes i found in my sandbox from montreal
by arma＠torproject.org 12 Jun '16

12 Jun '16

commit 0616fd6fb6db5385eac6b432892c90fbb38f8666 Author: Roger Dingledine <arma(a)torproject.org> Date: Sun Jun 12 16:14:15 2016 -0400 typo/comment/log fixes i found in my sandbox from montreal --- src/or/directory.c | 6 +++++- src/or/rendcache.c | 12 ++++++------ src/or/routerlist.c | 1 - 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/src/or/directory.c b/src/or/directory.c index abac19d..6caca11 100644 --- a/src/or/directory.c +++ b/src/or/directory.c @@ -727,6 +727,10 @@ directory_initiate_command_routerstatus_rend(const routerstatus_t *status, node = node_get_by_id(status->identity_digest); + /* XXX The below check is wrong: !node means it's not in the consensus, + * but we haven't checked if we have a descriptor for it -- and also, + * we only care about the descriptor if it's a begindir-style anonymized + * connection. */ if (!node && anonymized_connection) { log_info(LD_DIR, "Not sending anonymized request to directory '%s'; we " "don't have its router descriptor.", @@ -744,7 +748,7 @@ directory_initiate_command_routerstatus_rend(const routerstatus_t *status, return; } - /* At this point, if we are a clients making a direct connection to a + /* At this point, if we are a client making a direct connection to a * directory server, we have selected a server that has at least one address * allowed by ClientUseIPv4/6 and Reachable{"",OR,Dir}Addresses. This * selection uses the preference in ClientPreferIPv6{OR,Dir}Port, if diff --git a/src/or/rendcache.c b/src/or/rendcache.c index f8206cd..e61a96b 100644 --- a/src/or/rendcache.c +++ b/src/or/rendcache.c @@ -956,25 +956,25 @@ rend_cache_store_v2_desc_as_client(const char *desc, * avoid an evil HSDir serving old descriptor. We validate if the * timestamp is greater than and not equal because it's a rounded down * timestamp to the hour so if the descriptor changed in the same hour, - * the rend cache failure will tells us if we have a new descriptor. */ + * the rend cache failure will tell us if we have a new descriptor. */ if (e && e->parsed->timestamp > parsed->timestamp) { log_info(LD_REND, "We already have a new enough service descriptor for " "service ID %s with the same desc ID and version.", safe_str_client(service_id)); goto okay; } - /* Lookup our failure cache for intro point that might be unsuable. */ + /* Lookup our failure cache for intro point that might be unusable. */ validate_intro_point_failure(parsed, service_id); - /* It's now possible that our intro point list is empty, this means that + /* It's now possible that our intro point list is empty, which means that * this descriptor is useless to us because intro points have all failed * somehow before. Discard the descriptor. */ if (smartlist_len(parsed->intro_nodes) == 0) { - log_info(LD_REND, "Service descriptor with service ID %s, every " - "intro points are unusable. Discarding it.", + log_info(LD_REND, "Service descriptor with service ID %s has no " + "usable intro points. Discarding it.", safe_str_client(service_id)); goto err; } - /* Now either purge the current one and replace it's content or create a + /* Now either purge the current one and replace its content or create a * new one and add it to the rend cache. */ if (!e) { e = tor_malloc_zero(sizeof(rend_cache_entry_t)); diff --git a/src/or/routerlist.c b/src/or/routerlist.c index 02564e6..46492c5 100644 --- a/src/or/routerlist.c +++ b/src/or/routerlist.c @@ -322,7 +322,6 @@ already_have_cert(authority_cert_t *cert) * we've just successfully retrieved certificates from, so try it first to * fetch any missing certificates. */ - int trusted_dirs_load_certs_from_string(const char *contents, int source, int flush, const char *source_dir)

1 0

[snowflake/master] interfaces.go, SnowflakeCollector, better composition
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit 556596cc5aa14eecb687bbfb44188d1e733b6855 Author: Serene Han <keroserene+git(a)gmail.com> Date: Tue May 24 15:18:54 2016 -0700 interfaces.go, SnowflakeCollector, better composition --- client/client_test.go | 124 +++++++++++++++++++++++++------------- client/interfaces.go | 30 ++++++++++ client/snowflake.go | 161 +++++++++++++++++++++++--------------------------- client/webrtc.go | 18 ++++++ 4 files changed, 205 insertions(+), 128 deletions(-) diff --git a/client/client_test.go b/client/client_test.go index 1ccf206..0bd3844 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -3,12 +3,15 @@ package main import ( "bytes" "fmt" - "github.com/keroserene/go-webrtc" - . "github.com/smartystreets/goconvey/convey" "io/ioutil" + "net" "net/http" "strings" "testing" + + // "git.torproject.org/pluggable-transports/goptlib.git" + "github.com/keroserene/go-webrtc" + . "github.com/smartystreets/goconvey/convey" ) type MockDataChannel struct { @@ -56,56 +59,93 @@ func (w FakeDialer) Catch() (*webRTCConn, error) { return &webRTCConn{}, nil } +type FakeSocksConn struct { + net.Conn + rejected bool +} + +func (f FakeSocksConn) Reject() error { + f.rejected = true + return nil +} +func (f FakeSocksConn) Grant(addr *net.TCPAddr) error { + return nil +} + +type FakeSnowflakeJar struct { + toRelease *webRTCConn +} + +func (f FakeSnowflakeJar) Release() *webRTCConn { + return nil +} + +func (f FakeSnowflakeJar) Collect() (*webRTCConn, error) { + return nil, nil +} + func TestSnowflakeClient(t *testing.T) { - Convey("Snowflake", t, func() { - Convey("Peers", func() { + Convey("WebRTC ConnectLoop", t, func() { - Convey("WebRTC ConnectLoop continues until capacity of 1.\n", func() { - peers := NewPeers(1) - peers.Tongue = FakeDialer{} + Convey("WebRTC ConnectLoop continues until capacity of 1.\n", func() { + snowflakes := NewSnowflakeJar(1) + snowflakes.Tongue = FakeDialer{} - go ConnectLoop(peers) - <-peers.maxedChan + go ConnectLoop(snowflakes) + <-snowflakes.maxedChan - So(peers.Count(), ShouldEqual, 1) - r := <-peers.snowflakeChan - So(r, ShouldNotBeNil) - So(peers.Count(), ShouldEqual, 0) - }) + So(snowflakes.Count(), ShouldEqual, 1) + r := <-snowflakes.snowflakeChan + So(r, ShouldNotBeNil) + So(snowflakes.Count(), ShouldEqual, 0) + }) - Convey("WebRTC ConnectLoop continues until capacity of 3.\n", func() { - peers := NewPeers(3) - peers.Tongue = FakeDialer{} - - go ConnectLoop(peers) - <-peers.maxedChan - So(peers.Count(), ShouldEqual, 3) - <-peers.snowflakeChan - <-peers.snowflakeChan - <-peers.snowflakeChan - So(peers.Count(), ShouldEqual, 0) - }) + Convey("WebRTC ConnectLoop continues until capacity of 3.\n", func() { + snowflakes := NewSnowflakeJar(3) + snowflakes.Tongue = FakeDialer{} + + go ConnectLoop(snowflakes) + <-snowflakes.maxedChan + So(snowflakes.Count(), ShouldEqual, 3) + <-snowflakes.snowflakeChan + <-snowflakes.snowflakeChan + <-snowflakes.snowflakeChan + So(snowflakes.Count(), ShouldEqual, 0) + }) - Convey("WebRTC ConnectLoop continues filling when Snowflakes disconnect.\n", func() { - peers := NewPeers(3) - peers.Tongue = FakeDialer{} + Convey("WebRTC ConnectLoop continues filling when Snowflakes disconnect.\n", func() { + snowflakes := NewSnowflakeJar(3) + snowflakes.Tongue = FakeDialer{} - go ConnectLoop(peers) - <-peers.maxedChan - So(peers.Count(), ShouldEqual, 3) + go ConnectLoop(snowflakes) + <-snowflakes.maxedChan + So(snowflakes.Count(), ShouldEqual, 3) - r := <-peers.snowflakeChan - So(peers.Count(), ShouldEqual, 2) - r.Close() - <-peers.maxedChan - So(peers.Count(), ShouldEqual, 3) + r := <-snowflakes.snowflakeChan + So(snowflakes.Count(), ShouldEqual, 2) + r.Close() + <-snowflakes.maxedChan + So(snowflakes.Count(), ShouldEqual, 3) + + <-snowflakes.snowflakeChan + <-snowflakes.snowflakeChan + <-snowflakes.snowflakeChan + So(snowflakes.Count(), ShouldEqual, 0) + }) + }) + + Convey("Snowflake", t, func() { + + SkipConvey("Handler Grants correctly", func() { + socks := &FakeSocksConn{} + snowflakes := &FakeSnowflakeJar{} + + So(socks.rejected, ShouldEqual, false) + snowflakes.toRelease = nil + handler(socks, snowflakes) + So(socks.rejected, ShouldEqual, true) - <-peers.snowflakeChan - <-peers.snowflakeChan - <-peers.snowflakeChan - So(peers.Count(), ShouldEqual, 0) - }) }) Convey("WebRTC Connection", func() { diff --git a/client/interfaces.go b/client/interfaces.go new file mode 100644 index 0000000..80a2ba3 --- /dev/null +++ b/client/interfaces.go @@ -0,0 +1,30 @@ +package main + +import ( + "net" +) + +// Interface for collecting and releasing snowflakes. +type SnowflakeCollector interface { + Collect() (*webRTCConn, error) + Release() *webRTCConn +} + +// Interface for catching those wild Snowflakes. +type Tongue interface { + Catch() (*webRTCConn, error) +} + +// Interface which primarily adapts to goptlib's SocksConn struct. +type SocksConnector interface { + Grant(*net.TCPAddr) error + Reject() error + net.Conn +} + +// Interface for the Snowflake's transport. +// (Specifically, webrtc.DataChannel) +type SnowflakeChannel interface { + Send([]byte) + Close() error +} diff --git a/client/snowflake.go b/client/snowflake.go index 464420c..cd7f151 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -1,4 +1,5 @@ // Client transport plugin for the Snowflake pluggable transport. +// In the Client context, "Snowflake" refers to a remote browser proxy. package main import ( @@ -49,22 +50,12 @@ func copyLoop(a, b net.Conn) { log.Println("copy loop ended") } -// Interface for catching Snowflakes. -type Tongue interface { - Catch() (*webRTCConn, error) -} - -// Interface for the Snowflake transport. (usually a webrtc.DataChannel) -type SnowflakeChannel interface { - Send([]byte) - Close() error -} - -// Collect and track available remote WebRTC Peers, to switch between if the -// current one disconnects. -// Right now, it is only possible to use one remote in a circuit. This can be -// updated once multiplexed transport on a single circuit is available. -type Peers struct { +// Collect and track available snowflakes. (Implements SnowflakeCollector) +// Right now, it is only possible to use one active remote in a circuit. +// This can be updated once multiplexed transport on a single circuit is available. +// Keeping multiple WebRTC connections available allows for quicker recovery when +// the current snowflake disconnects. +type SnowflakeJar struct { Tongue BytesLogger @@ -74,30 +65,42 @@ type Peers struct { maxedChan chan struct{} } -func NewPeers(max int) *Peers { - p := &Peers{capacity: max} +func NewSnowflakeJar(max int) *SnowflakeJar { + p := &SnowflakeJar{capacity: max} p.snowflakeChan = make(chan *webRTCConn, max) p.maxedChan = make(chan struct{}, 1) return p } -// Find, connect, and add a new peer to the internal collection. -func (p *Peers) FindSnowflake() (*webRTCConn, error) { - if p.Count() >= p.capacity { - s := fmt.Sprintf("At capacity [%d/%d]", p.Count(), p.capacity) - p.maxedChan <- struct{}{} +// Establish connection to some remote WebRTC peer, and keep it available for +// later. +func (jar *SnowflakeJar) Collect() (*webRTCConn, error) { + if jar.Count() >= jar.capacity { + s := fmt.Sprintf("At capacity [%d/%d]", jar.Count(), jar.capacity) + jar.maxedChan <- struct{}{} return nil, errors.New(s) } - connection, err := p.Catch() - connection.BytesLogger = p.BytesLogger + snowflake, err := jar.Catch() if err != nil { return nil, err } - return connection, nil + jar.snowflakeChan <- snowflake + return snowflake, nil +} + +// Prepare and present an available remote WebRTC peer for active use. +func (jar *SnowflakeJar) Release() *webRTCConn { + snowflake, ok := <-jar.snowflakeChan + if !ok { + return nil + } + jar.current = snowflake + snowflake.BytesLogger = jar.BytesLogger + return snowflake } // TODO: Needs fixing. -func (p *Peers) Count() int { +func (p *SnowflakeJar) Count() int { count := 0 if p.current != nil { count = 1 @@ -106,7 +109,7 @@ func (p *Peers) Count() int { } // Close all remote peers. -func (p *Peers) End() { +func (p *SnowflakeJar) End() { log.Printf("WebRTC: interruped") if nil != p.current { p.current.Close() @@ -118,87 +121,71 @@ func (p *Peers) End() { // Maintain |SnowflakeCapacity| number of available WebRTC connections, to // transfer to the Tor SOCKS handler when needed. -func ConnectLoop(peers *Peers) { +func ConnectLoop(snowflakes SnowflakeCollector) { for { - s, err := peers.FindSnowflake() + s, err := snowflakes.Collect() if nil == s || nil != err { log.Println("WebRTC Error:", err, " Retrying in", ReconnectTimeout, "seconds...") + // Failed collections get a timeout. <-time.After(time.Second * ReconnectTimeout) continue } - peers.snowflakeChan <- s + // Successful collection gets rate limited to once per second. <-time.After(time.Second) } } -// Implements |Tongue| -type WebRTCDialer struct { - *BrokerChannel -} - -// Initialize a WebRTC Connection by signaling through the broker. -func (w WebRTCDialer) Catch() (*webRTCConn, error) { - if nil == w.BrokerChannel { - return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.") +// Accept local SOCKS connections and pass them to the handler. +func acceptLoop(ln *pt.SocksListener, snowflakes SnowflakeCollector) error { + defer ln.Close() + for { + log.Println("SOCKS listening...", ln) + conn, err := ln.AcceptSocks() + log.Println("accepting", conn, err) + if err != nil { + if e, ok := err.(net.Error); ok && e.Temporary() { + continue + } + return err + } + err = handler(conn, snowflakes) + if err != nil { + log.Printf("handler error: %s", err) + } } - // TODO: [#3] Fetch ICE server information from Broker. - // TODO: [#18] Consider TURN servers here too. - config := webrtc.NewConfiguration(iceServers...) - connection := NewWebRTCConnection(config, w.BrokerChannel) - err := connection.Connect() - return connection, err } -// Establish a WebRTC channel for SOCKS connections. -func handler(conn *pt.SocksConn, peers *Peers) error { +// Given an accepted SOCKS connection, establish a WebRTC connection to the +// remote peer and exchange traffic. +func handler(socks SocksConnector, snowflakes SnowflakeCollector) error { handlerChan <- 1 defer func() { handlerChan <- -1 }() // Wait for an available WebRTC remote... - remote, ok := <-peers.snowflakeChan - peers.current = remote - if remote == nil || !ok { - conn.Reject() + snowflake := snowflakes.Release() + if nil == snowflake { + socks.Reject() return errors.New("handler: Received invalid Snowflake") } - defer conn.Close() + defer socks.Close() log.Println("handler: Snowflake assigned.") - - err := conn.Grant(&net.TCPAddr{IP: net.IPv4zero, Port: 0}) + err := socks.Grant(&net.TCPAddr{IP: net.IPv4zero, Port: 0}) if err != nil { return err } - go copyLoop(conn, remote) + // Begin exchanging data. + go copyLoop(socks, snowflake) + // When WebRTC resets, close the SOCKS connection, which induces new handler. - <-remote.reset + // TODO: Double check this / fix it. + <-snowflake.reset log.Println("---- Closed ---") return nil } -func acceptLoop(ln *pt.SocksListener, peers *Peers) error { - defer ln.Close() - for { - log.Println("SOCKS listening...", ln) - conn, err := ln.AcceptSocks() - log.Println("accepting", conn, err) - if err != nil { - if e, ok := err.(net.Error); ok && e.Temporary() { - continue - } - return err - } - go func() { - err := handler(conn, peers) - if err != nil { - log.Printf("handler error: %s", err) - } - }() - } -} - // TODO: Fix since multiplexing changes access to remotes. func readSignalingMessages(f *os.File) { log.Printf("readSignalingMessages") @@ -258,19 +245,21 @@ func main() { go readSignalingMessages(signalFile) } - // Prepare WebRTC Peers and the Broker, then accumulate connections. + // Prepare WebRTC SnowflakeCollector and the Broker, then accumulate connections. // TODO: Expose remote peer capacity as a flag? - remotes := NewPeers(SnowflakeCapacity) + snowflakes := NewSnowflakeJar(SnowflakeCapacity) + broker := NewBrokerChannel(brokerURL, frontDomain, CreateBrokerTransport()) + snowflakes.Tongue = WebRTCDialer{broker} - remotes.BytesLogger = &BytesSyncLogger{ + // Use a real logger for traffic. + snowflakes.BytesLogger = &BytesSyncLogger{ inboundChan: make(chan int, 5), outboundChan: make(chan int, 5), inbound: 0, outbound: 0, inEvents: 0, outEvents: 0, } - go remotes.BytesLogger.Log() - remotes.Tongue = WebRTCDialer{broker} - go ConnectLoop(remotes) + go ConnectLoop(snowflakes) + go snowflakes.BytesLogger.Log() ptInfo, err = pt.ClientSetup(nil) if err != nil { @@ -292,7 +281,7 @@ func main() { pt.CmethodError(methodName, err.Error()) break } - go acceptLoop(ln, remotes) + go acceptLoop(ln, snowflakes) pt.Cmethod(methodName, ln.Version(), ln.Addr()) listeners = append(listeners, ln) default: @@ -319,7 +308,7 @@ func main() { ln.Close() } - remotes.End() + snowflakes.End() // wait for second signal or no more handlers sig = nil diff --git a/client/webrtc.go b/client/webrtc.go index a47ac19..41642be 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -11,6 +11,24 @@ import ( "time" ) +// Implements the |Tongue| interface to catch snowflakes, using a BrokerChannel. +type WebRTCDialer struct { + *BrokerChannel +} + +// Initialize a WebRTC Connection by signaling through the broker. +func (w WebRTCDialer) Catch() (*webRTCConn, error) { + if nil == w.BrokerChannel { + return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.") + } + // TODO: [#3] Fetch ICE server information from Broker. + // TODO: [#18] Consider TURN servers here too. + config := webrtc.NewConfiguration(iceServers...) + connection := NewWebRTCConnection(config, w.BrokerChannel) + err := connection.Connect() + return connection, err +} + // Remote WebRTC peer. Implements the |net.Conn| interface. type webRTCConn struct { config *webrtc.Configuration

1 0

[snowflake/master] localize ptInfo and iceServers vars, separate copy-paste helpers, move some logging
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit fedb124313a532aa4f105f3d7575245b99e3e92c Author: Serene Han <keroserene+git(a)gmail.com> Date: Sun Jun 12 11:49:32 2016 -0700 localize ptInfo and iceServers vars, separate copy-paste helpers, move some logging to more sensible locations --- client/peers.go | 2 ++ client/rendezvous.go | 2 ++ client/snowflake.go | 68 +++++++++++++++++++++++++--------------------------- client/webrtc.go | 7 +++--- 4 files changed, 41 insertions(+), 38 deletions(-) diff --git a/client/peers.go b/client/peers.go index 8aeb838..734fdfe 100644 --- a/client/peers.go +++ b/client/peers.go @@ -38,6 +38,7 @@ func NewPeers(max int) *Peers { // As part of |SnowflakeCollector| interface. func (p *Peers) Collect() error { + cnt := p.Count() if cnt >= p.capacity { s := fmt.Sprintf("At capacity [%d/%d]", cnt, p.capacity) @@ -59,6 +60,7 @@ func (p *Peers) Collect() error { // As part of |SnowflakeCollector| interface. func (p *Peers) Pop() *webRTCConn { + // Blocks until an available snowflake appears. snowflake, ok := <-p.snowflakeChan if !ok { diff --git a/client/rendezvous.go b/client/rendezvous.go index fbb75dd..3b25c89 100644 --- a/client/rendezvous.go +++ b/client/rendezvous.go @@ -46,9 +46,11 @@ func NewBrokerChannel(broker string, front string, transport http.RoundTripper) if nil != err { return nil } + log.Println("Rendezvous using Broker at:", broker) bc := new(BrokerChannel) bc.url = targetURL if "" != front { // Optional front domain. + log.Println("Domain fronting using:", front) bc.Host = bc.url.Host bc.url.Host = front } diff --git a/client/snowflake.go b/client/snowflake.go index 1c17642..948b862 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -18,15 +18,11 @@ import ( "github.com/keroserene/go-webrtc" ) -var ptInfo pt.ClientInfo - const ( ReconnectTimeout = 10 DefaultSnowflakeCapacity = 1 ) -var iceServers IceServerList - // When a connection handler starts, +1 is written to this channel; when it // ends, -1 is written. var handlerChan = make(chan int) @@ -52,20 +48,20 @@ func ConnectLoop(snowflakes SnowflakeCollector) { for { err := snowflakes.Collect() if nil != err { - log.Println("WebRTC Error:", err, + log.Println("WebRTC:", err, " Retrying in", ReconnectTimeout, "seconds...") // Failed collections get a timeout. <-time.After(time.Second * ReconnectTimeout) continue } // Successful collection gets rate limited to once per second. - log.Println("ConnectLoop success.") + log.Println("WebRTC: Connected to new Snowflake.") <-time.After(time.Second) } } // Accept local SOCKS connections and pass them to the handler. -func acceptLoop(ln *pt.SocksListener, snowflakes SnowflakeCollector) error { +func socksAcceptLoop(ln *pt.SocksListener, snowflakes SnowflakeCollector) error { defer ln.Close() log.Println("Started SOCKS listener.") for { @@ -98,7 +94,7 @@ func handler(socks SocksConnector, snowflakes SnowflakeCollector) error { return errors.New("handler: Received invalid Snowflake") } defer socks.Close() - log.Println("handler: Snowflake assigned.") + log.Println("---- Snowflake assigned ----") err := socks.Grant(&net.TCPAddr{IP: net.IPv4zero, Port: 0}) if err != nil { return err @@ -114,7 +110,25 @@ func handler(socks SocksConnector, snowflakes SnowflakeCollector) error { return nil } -// TODO: Fix since multiplexing changes access to remotes. +func setupCopyPaste() { + log.Println("No HTTP signaling detected. Waiting for a \"signal\" pipe...") + // This FIFO receives signaling messages. + err := syscall.Mkfifo("signal", 0600) + if err != nil { + if syscall.EEXIST != err.(syscall.Errno) { + log.Fatal(err) + } + } + signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600) + if nil != err { + log.Fatal(err) + } + defer signalFile.Close() + go readSignalingMessages(signalFile) +} + +// Manual copy-paste signalling. +// TODO: Needs fix since multiplexing changes access to the remotes. func readSignalingMessages(f *os.File) { log.Printf("readSignalingMessages") s := bufio.NewScanner(f) @@ -144,42 +158,26 @@ func main() { } defer logFile.Close() log.SetOutput(logFile) - log.Println("\nStarting Snowflake Client...") + var iceServers IceServerList + log.Println("\n\n\n --- Starting Snowflake Client ---") + + flag.Var(&iceServers, "ice", "comma-separated list of ICE servers") brokerURL := flag.String("url", "", "URL of signaling broker") frontDomain := flag.String("front", "", "front domain") - flag.Var(&iceServers, "ice", "comma-separated list of ICE servers") max := flag.Int("max", DefaultSnowflakeCapacity, "capacity for number of multiplexed WebRTC peers") flag.Parse() // TODO: Maybe just get rid of copy-paste option entirely. - if "" != *brokerURL { - log.Println("Rendezvous using Broker at: ", *brokerURL) - if "" != *frontDomain { - log.Println("Domain fronting using:", *frontDomain) - } - } else { - log.Println("No HTTP signaling detected. Waiting for a \"signal\" pipe...") - // This FIFO receives signaling messages. - err := syscall.Mkfifo("signal", 0600) - if err != nil { - if err.(syscall.Errno) != syscall.EEXIST { - log.Fatal(err) - } - } - signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600) - if err != nil { - log.Fatal(err) - } - defer signalFile.Close() - go readSignalingMessages(signalFile) + if "" == *brokerURL { + setupCopyPaste() } // Prepare WebRTC SnowflakeCollector, Broker, then accumulate connections. snowflakes := NewPeers(*max) broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport()) - snowflakes.Tongue = NewWebRTCDialer(broker) + snowflakes.Tongue = NewWebRTCDialer(broker, iceServers) // Use a real logger for traffic. snowflakes.BytesLogger = &BytesSyncLogger{ @@ -190,11 +188,11 @@ func main() { go ConnectLoop(snowflakes) go snowflakes.BytesLogger.Log() - ptInfo, err = pt.ClientSetup(nil) + // Begin goptlib client process. + ptInfo, err := pt.ClientSetup(nil) if err != nil { log.Fatal(err) } - if ptInfo.ProxyURL != nil { pt.ProxyError("proxy is not supported") os.Exit(1) @@ -210,7 +208,7 @@ func main() { pt.CmethodError(methodName, err.Error()) break } - go acceptLoop(ln, snowflakes) + go socksAcceptLoop(ln, snowflakes) pt.Cmethod(methodName, ln.Version(), ln.Addr()) listeners = append(listeners, ln) default: diff --git a/client/webrtc.go b/client/webrtc.go index c978f12..7647cf6 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -17,7 +17,9 @@ type WebRTCDialer struct { webrtcConfig *webrtc.Configuration } -func NewWebRTCDialer(broker *BrokerChannel) *WebRTCDialer { +func NewWebRTCDialer( + broker *BrokerChannel, iceServers IceServerList) *WebRTCDialer { + config := webrtc.NewConfiguration(iceServers...) return &WebRTCDialer{ BrokerChannel: broker, @@ -32,8 +34,7 @@ func (w WebRTCDialer) Catch() (*webRTCConn, error) { } // TODO: [#3] Fetch ICE server information from Broker. // TODO: [#18] Consider TURN servers here too. - config := webrtc.NewConfiguration(iceServers...) - connection := NewWebRTCConnection(config, w.BrokerChannel) + connection := NewWebRTCConnection(w.webrtcConfig, w.BrokerChannel) err := connection.Connect() return connection, err }

1 0

[snowflake/master] copy-paste rendezvous works again, but with new interface allowing seamless recovery for the first time
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit 02562ba7504811659d801d06d9fdb1c3ecfa5d9b Author: Serene Han <keroserene+git(a)gmail.com> Date: Sun Jun 12 12:43:24 2016 -0700 copy-paste rendezvous works again, but with new interface allowing seamless recovery for the first time --- client/rendezvous.go | 112 +++++++++++++++++++++++++++++++++++++++++++++++++-- client/snowflake.go | 65 +++++------------------------- client/webrtc.go | 32 +-------------- 3 files changed, 122 insertions(+), 87 deletions(-) diff --git a/client/rendezvous.go b/client/rendezvous.go index 3b25c89..0acee80 100644 --- a/client/rendezvous.go +++ b/client/rendezvous.go @@ -1,15 +1,26 @@ -// WebRTC Rendezvous requires the exchange of SessionDescriptions between -// peers. This file contains the domain-fronted HTTP signaling mechanism -// between the client and a desired Broker. +// WebRTC rendezvous requires the exchange of SessionDescriptions between +// peers in order to establish a PeerConnection. +// +// This file contains the two methods currently available to Snowflake: +// +// - Domain-fronted HTTP signaling. The Broker automatically exchange offers +// and answers between this client and some remote WebRTC proxy. +// (This is the recommended default, enabled via the flags in "torrc".) +// +// - Manual copy-paste signaling. User must create a signaling pipe. +// (The flags in torrc-manual allow this) package main import ( + "bufio" "bytes" "errors" "io/ioutil" "log" "net/http" "net/url" + "os" + "syscall" "github.com/keroserene/go-webrtc" ) @@ -100,3 +111,98 @@ func (bc *BrokerChannel) Negotiate(offer *webrtc.SessionDescription) ( return nil, errors.New(BrokerErrorUnexpected) } } + +// Implements the |Tongue| interface to catch snowflakes, using BrokerChannel. +type WebRTCDialer struct { + *BrokerChannel + webrtcConfig *webrtc.Configuration +} + +func NewWebRTCDialer( + broker *BrokerChannel, iceServers IceServerList) *WebRTCDialer { + config := webrtc.NewConfiguration(iceServers...) + return &WebRTCDialer{ + BrokerChannel: broker, + webrtcConfig: config, + } +} + +// Initialize a WebRTC Connection by signaling through the broker. +func (w WebRTCDialer) Catch() (*webRTCConn, error) { + if nil == w.BrokerChannel { + return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.") + } + // TODO: [#3] Fetch ICE server information from Broker. + // TODO: [#18] Consider TURN servers here too. + connection := NewWebRTCConnection(w.webrtcConfig, w.BrokerChannel) + err := connection.Connect() + return connection, err +} + +// CopyPasteDialer handles the interaction required to copy-paste the +// offers and answers. +// Implements |Tongue| interface to catch snowflakes manually. +// Supports recovery of connections. +type CopyPasteDialer struct { + webrtcConfig *webrtc.Configuration + signal *os.File + current *webRTCConn +} + +func NewCopyPasteDialer(iceServers IceServerList) *CopyPasteDialer { + log.Println("No HTTP signaling detected. Using manual copy-paste signaling.") + log.Println("Waiting for a \"signal\" pipe...") + // This FIFO receives signaling messages. + err := syscall.Mkfifo("signal", 0600) + if err != nil { + if syscall.EEXIST != err.(syscall.Errno) { + log.Fatal(err) + } + } + signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600) + if nil != err { + log.Fatal(err) + return nil + } + config := webrtc.NewConfiguration(iceServers...) + dialer := &CopyPasteDialer{ + webrtcConfig: config, + signal: signalFile, + } + go dialer.readSignals() + return dialer +} + +// Initialize a WebRTC connection via manual copy-paste. +func (d *CopyPasteDialer) Catch() (*webRTCConn, error) { + if nil == d.signal { + return nil, errors.New("Cannot copy-paste dial without signal pipe.") + } + connection := NewWebRTCConnection(d.webrtcConfig, nil) + // Must keep track of pending new connection until copy-paste completes. + d.current = connection + // Outputs SDP offer to log, expecting user to copy-paste to the remote Peer. + // Blocks until user pastes back the answer. + err := connection.Connect() + d.current = nil + return connection, err +} + +// Manual copy-paste signalling. +func (d *CopyPasteDialer) readSignals() { + defer d.signal.Close() + log.Printf("CopyPasteDialer: reading messages from signal pipe.") + s := bufio.NewScanner(d.signal) + for s.Scan() { + msg := s.Text() + sdp := webrtc.DeserializeSessionDescription(msg) + if sdp == nil { + log.Printf("CopyPasteDialer: ignoring invalid signal message %+q", msg) + continue + } + d.current.answerChannel <- sdp + } + if err := s.Err(); err != nil { + log.Printf("signal FIFO: %s", err) + } +} diff --git a/client/snowflake.go b/client/snowflake.go index 948b862..7c06b17 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -2,7 +2,6 @@ package main import ( - "bufio" "errors" "flag" "io" @@ -110,45 +109,6 @@ func handler(socks SocksConnector, snowflakes SnowflakeCollector) error { return nil } -func setupCopyPaste() { - log.Println("No HTTP signaling detected. Waiting for a \"signal\" pipe...") - // This FIFO receives signaling messages. - err := syscall.Mkfifo("signal", 0600) - if err != nil { - if syscall.EEXIST != err.(syscall.Errno) { - log.Fatal(err) - } - } - signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600) - if nil != err { - log.Fatal(err) - } - defer signalFile.Close() - go readSignalingMessages(signalFile) -} - -// Manual copy-paste signalling. -// TODO: Needs fix since multiplexing changes access to the remotes. -func readSignalingMessages(f *os.File) { - log.Printf("readSignalingMessages") - s := bufio.NewScanner(f) - for s.Scan() { - msg := s.Text() - log.Printf("readSignalingMessages loop %+q", msg) - sdp := webrtc.DeserializeSessionDescription(msg) - if sdp == nil { - log.Printf("ignoring invalid signal message %+q", msg) - continue - } - // webrtcRemotes[0].answerChannel <- sdp - } - log.Printf("close answerChannel") - // close(webrtcRemotes[0].answerChannel) - if err := s.Err(); err != nil { - log.Printf("signal FIFO: %s", err) - } -} - func main() { webrtc.SetLoggingVerbosity(1) logFile, err := os.OpenFile("snowflake.log", @@ -169,24 +129,24 @@ func main() { "capacity for number of multiplexed WebRTC peers") flag.Parse() - // TODO: Maybe just get rid of copy-paste option entirely. - if "" == *brokerURL { - setupCopyPaste() - } - - // Prepare WebRTC SnowflakeCollector, Broker, then accumulate connections. + // Prepare to collect remote WebRTC peers. snowflakes := NewPeers(*max) - broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport()) - snowflakes.Tongue = NewWebRTCDialer(broker, iceServers) - - // Use a real logger for traffic. + if "" != *brokerURL { + // Use potentially domain-fronting broker to rendezvous. + broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport()) + snowflakes.Tongue = NewWebRTCDialer(broker, iceServers) + } else { + // Otherwise, use manual copy and pasting of SDP messages. + snowflakes.Tongue = NewCopyPasteDialer(iceServers) + } + // Use a real logger to periodically output how much traffic is happening. snowflakes.BytesLogger = &BytesSyncLogger{ inboundChan: make(chan int, 5), outboundChan: make(chan int, 5), inbound: 0, outbound: 0, inEvents: 0, outEvents: 0, } + go snowflakes.BytesLogger.Log() go ConnectLoop(snowflakes) - go snowflakes.BytesLogger.Log() // Begin goptlib client process. ptInfo, err := pt.ClientSetup(nil) @@ -197,7 +157,6 @@ func main() { pt.ProxyError("proxy is not supported") os.Exit(1) } - listeners := make([]net.Listener, 0) for _, methodName := range ptInfo.MethodNames { switch methodName { @@ -234,9 +193,7 @@ func main() { for _, ln := range listeners { ln.Close() } - snowflakes.End() - // wait for second signal or no more handlers sig = nil for sig == nil && numHandlers != 0 { diff --git a/client/webrtc.go b/client/webrtc.go index 7647cf6..2d26b7a 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -11,34 +11,6 @@ import ( "time" ) -// Implements the |Tongue| interface to catch snowflakes, using a BrokerChannel. -type WebRTCDialer struct { - *BrokerChannel - webrtcConfig *webrtc.Configuration -} - -func NewWebRTCDialer( - broker *BrokerChannel, iceServers IceServerList) *WebRTCDialer { - - config := webrtc.NewConfiguration(iceServers...) - return &WebRTCDialer{ - BrokerChannel: broker, - webrtcConfig: config, - } -} - -// Initialize a WebRTC Connection by signaling through the broker. -func (w WebRTCDialer) Catch() (*webRTCConn, error) { - if nil == w.BrokerChannel { - return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.") - } - // TODO: [#3] Fetch ICE server information from Broker. - // TODO: [#18] Consider TURN servers here too. - connection := NewWebRTCConnection(w.webrtcConfig, w.BrokerChannel) - err := connection.Connect() - return connection, err -} - // Remote WebRTC peer. Implements the |net.Conn| interface. type webRTCConn struct { config *webrtc.Configuration @@ -282,11 +254,11 @@ func (c *webRTCConn) sendOfferToBroker() { func (c *webRTCConn) exchangeSDP() error { select { case offer := <-c.offerChannel: - // Display for copy-paste, when no broker available. + // Display for copy-paste when no broker available. if nil == c.broker { log.Printf("Please Copy & Paste the following to the peer:") log.Printf("----------------") - log.Printf("\n" + offer.Serialize() + "\n") + log.Printf("\n\n" + offer.Serialize() + "\n\n") log.Printf("----------------") } case err := <-c.errorChannel:

1 0

[snowflake/master] fix Peers.Count() using activePeers list, mark for delete on Close, and remove
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit 2caa47988dc2e7d78db083d2609b8656e4731079 Author: Serene Han <keroserene+git(a)gmail.com> Date: Sat Jun 11 23:18:38 2016 -0700 fix Peers.Count() using activePeers list, mark for delete on Close, and remove maxedChan --- client/client_test.go | 77 +++++++++++++++++++++++++++++++-------------------- client/peers.go | 72 ++++++++++++++++++++++++++--------------------- client/snowflake.go | 8 ++++-- client/webrtc.go | 5 ++-- 4 files changed, 95 insertions(+), 67 deletions(-) diff --git a/client/client_test.go b/client/client_test.go index f58aeb0..de83768 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -75,7 +75,7 @@ func TestSnowflakeClient(t *testing.T) { snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) - <-snowflakes.maxedChan + // <-snowflakes.maxedChan So(snowflakes.Count(), ShouldEqual, 1) r := <-snowflakes.snowflakeChan @@ -88,7 +88,7 @@ func TestSnowflakeClient(t *testing.T) { snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) - <-snowflakes.maxedChan + // <-snowflakes.maxedChan So(snowflakes.Count(), ShouldEqual, 3) <-snowflakes.snowflakeChan <-snowflakes.snowflakeChan @@ -101,13 +101,13 @@ func TestSnowflakeClient(t *testing.T) { snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) - <-snowflakes.maxedChan + // <-snowflakes.maxedChan So(snowflakes.Count(), ShouldEqual, 3) r := <-snowflakes.snowflakeChan So(snowflakes.Count(), ShouldEqual, 2) r.Close() - <-snowflakes.maxedChan + // <-snowflakes.maxedChan So(snowflakes.Count(), ShouldEqual, 3) <-snowflakes.snowflakeChan @@ -121,7 +121,6 @@ func TestSnowflakeClient(t *testing.T) { Convey("Can construct", func() { p := NewPeers(1) So(p.capacity, ShouldEqual, 1) - So(p.current, ShouldEqual, nil) So(p.snowflakeChan, ShouldNotBeNil) So(cap(p.snowflakeChan), ShouldEqual, 1) }) @@ -136,36 +135,54 @@ func TestSnowflakeClient(t *testing.T) { err = p.Collect() So(err, ShouldBeNil) So(p.Count(), ShouldEqual, 1) - // S + // S err = p.Collect() }) Convey("Collection continues until capacity.", func() { - c := 5 + c := 5 p := NewPeers(c) - p.Tongue = FakeDialer{} - // Fill up to capacity. - for i := 0 ; i < c ; i++ { - fmt.Println("Adding snowflake ", i) - err := p.Collect() - So(err, ShouldBeNil) - So(p.Count(), ShouldEqual, i + 1) - } - // But adding another gives an error. - So(p.Count(), ShouldEqual, c) - err := p.Collect() - So(err, ShouldNotBeNil) - So(p.Count(), ShouldEqual, c) - - // But popping allows it to continue. - s := p.Pop() - So(s, ShouldNotBeNil) - So(p.Count(), ShouldEqual, c) - - // err = p.Collect() - // So(err, ShouldNotBeNil) - // So(p.Count(), ShouldEqual, c) - }) + p.Tongue = FakeDialer{} + // Fill up to capacity. + for i := 0; i < c; i++ { + fmt.Println("Adding snowflake ", i) + err := p.Collect() + So(err, ShouldBeNil) + So(p.Count(), ShouldEqual, i+1) + } + // But adding another gives an error. + So(p.Count(), ShouldEqual, c) + err := p.Collect() + So(err, ShouldNotBeNil) + So(p.Count(), ShouldEqual, c) + + // But popping and closing allows it to continue. + s := p.Pop() + s.Close() + So(s, ShouldNotBeNil) + So(p.Count(), ShouldEqual, c-1) + + err = p.Collect() + So(err, ShouldBeNil) + So(p.Count(), ShouldEqual, c) + }) + + Convey("Count correctly purges peers marked for deletion.", func() { + p := NewPeers(4) + p.Tongue = FakeDialer{} + p.Collect() + p.Collect() + p.Collect() + p.Collect() + So(p.Count(), ShouldEqual, 4) + s := p.Pop() + s.Close() + So(p.Count(), ShouldEqual, 3) + s = p.Pop() + s.Close() + So(p.Count(), ShouldEqual, 2) + }) + }) Convey("Snowflake", t, func() { diff --git a/client/peers.go b/client/peers.go index 769174b..57570bf 100644 --- a/client/peers.go +++ b/client/peers.go @@ -1,6 +1,7 @@ package main import ( + "container/list" "errors" "fmt" "log" @@ -22,70 +23,77 @@ type Peers struct { BytesLogger snowflakeChan chan *webRTCConn - current *webRTCConn + activePeers *list.List capacity int - // TODO: Probably not necessary. - maxedChan chan struct{} } // Construct a fresh container of remote peers. func NewPeers(max int) *Peers { - p := &Peers{capacity: max, current: nil} + p := &Peers{capacity: max} // Use buffered go channel to pass new snowflakes onwards to the SOCKS handler. p.snowflakeChan = make(chan *webRTCConn, max) - p.maxedChan = make(chan struct{}, 1) + p.activePeers = list.New() return p } -// TODO: Needs fixing. -func (p *Peers) Count() int { - count := 0 - if p.current != nil { - count = 1 - } - return count + len(p.snowflakeChan) -} - // As part of |SnowflakeCollector| interface. func (p *Peers) Collect() error { - if p.Count() >= p.capacity { - s := fmt.Sprintf("At capacity [%d/%d]", p.Count(), p.capacity) - p.maxedChan <- struct{}{} + cnt := p.Count() + if cnt >= p.capacity { + s := fmt.Sprintf("At capacity [%d/%d]", cnt, p.capacity) return errors.New(s) } - // Engage the Snowflake Catching interface, which must be available. + // Engage the Snowflake Catching interface, which must be available. if nil == p.Tongue { return errors.New("Missing Tongue to catch Snowflakes with.") } connection, err := p.Tongue.Catch() - if nil == connection || nil != err { - return err - } - // Use the same rate-limited traffic logger to keep consistency. - connection.BytesLogger = p.BytesLogger + if nil == connection || nil != err { + return err + } + // Track new valid Snowflake in internal collection and pass along. + p.activePeers.PushBack(connection) p.snowflakeChan <- connection return nil } // As part of |SnowflakeCollector| interface. func (p *Peers) Pop() *webRTCConn { - // Blocks until an available snowflake appears. + // Blocks until an available snowflake appears. snowflake, ok := <-p.snowflakeChan if !ok { return nil } - p.current = snowflake + // Set to use the same rate-limited traffic logger to keep consistency. snowflake.BytesLogger = p.BytesLogger return snowflake } -// Close all remote peers. -func (p *Peers) End() { - log.Printf("WebRTC: interruped") - if nil != p.current { - p.current.Close() +// Returns total available Snowflakes (including the active one) +// The count only reduces when connections themselves close, rather than when +// they are popped. +func (p *Peers) Count() int { + p.purgeClosedPeers() + return p.activePeers.Len() +} + +func (p *Peers) purgeClosedPeers() { + for e := p.activePeers.Front(); e != nil; { + next := e.Next() + conn := e.Value.(*webRTCConn) + // Purge those marked for deletion. + if conn.closed { + p.activePeers.Remove(e) + } + e = next } - for r := range p.snowflakeChan { - r.Close() +} + +// Close all Peers contained here. +func (p *Peers) End() { + log.Printf("WebRTC: Ending all peer connections.") + for e := p.activePeers.Front(); e != nil; e = e.Next() { + conn := e.Value.(*webRTCConn) + conn.Close() } } diff --git a/client/snowflake.go b/client/snowflake.go index f8edc2a..aa0e470 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -61,6 +61,7 @@ func ConnectLoop(snowflakes SnowflakeCollector) { continue } // Successful collection gets rate limited to once per second. + log.Println("ConnectLoop success.") <-time.After(time.Second) } } @@ -68,10 +69,10 @@ func ConnectLoop(snowflakes SnowflakeCollector) { // Accept local SOCKS connections and pass them to the handler. func acceptLoop(ln *pt.SocksListener, snowflakes SnowflakeCollector) error { defer ln.Close() + log.Println("Started SOCKS listener.") for { - log.Println("SOCKS listening...", ln) conn, err := ln.AcceptSocks() - log.Println("accepting", conn, err) + log.Println("SOCKS accepted ", conn.Req) if err != nil { if e, ok := err.(net.Error); ok && e.Temporary() { continue @@ -138,7 +139,8 @@ func readSignalingMessages(f *os.File) { func main() { webrtc.SetLoggingVerbosity(1) - logFile, err := os.OpenFile("snowflake.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600) + logFile, err := os.OpenFile("snowflake.log", + os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600) if err != nil { log.Fatal(err) } diff --git a/client/webrtc.go b/client/webrtc.go index 2466a1d..87a1d19 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -18,9 +18,10 @@ type WebRTCDialer struct { } func NewWebRTCDialer(broker *BrokerChannel) *WebRTCDialer { + config := webrtc.NewConfiguration(iceServers...) return &WebRTCDialer{ - broker, - webrtc.NewConfiguration(iceServers...), + BrokerChannel: broker, + webrtcConfig: config, } }

1 0

[snowflake/master] Separate peers.go file with improved documentation and more solid interfaces
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit c63f5cfc0a391af99cfa52ab90c05b9f0b253854 Author: Serene Han <keroserene+git(a)gmail.com> Date: Sat Jun 11 18:24:08 2016 -0700 Separate peers.go file with improved documentation and more solid interfaces --- client/client_test.go | 94 ++++++++++++++++++++++++++++++++++----------------- client/interfaces.go | 28 +++++++++------ client/peers.go | 91 +++++++++++++++++++++++++++++++++++++++++++++++++ client/snowflake.go | 83 ++++----------------------------------------- client/webrtc.go | 10 +++++- 5 files changed, 186 insertions(+), 120 deletions(-) diff --git a/client/client_test.go b/client/client_test.go index 0bd3844..f58aeb0 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -9,7 +9,6 @@ import ( "strings" "testing" - // "git.torproject.org/pluggable-transports/goptlib.git" "github.com/keroserene/go-webrtc" . "github.com/smartystreets/goconvey/convey" ) @@ -24,9 +23,7 @@ func (m *MockDataChannel) Send(data []byte) { m.done <- true } -func (*MockDataChannel) Close() error { - return nil -} +func (*MockDataChannel) Close() error { return nil } type MockResponse struct{} @@ -34,13 +31,9 @@ func (m *MockResponse) Read(p []byte) (int, error) { p = []byte(`{"type":"answer","sdp":"fake"}`) return 0, nil } -func (m *MockResponse) Close() error { - return nil -} +func (m *MockResponse) Close() error { return nil } -type MockTransport struct { - statusOverride int -} +type MockTransport struct{ statusOverride int } // Just returns a response with fake SDP answer. func (m *MockTransport) RoundTrip(req *http.Request) (*http.Response, error) { @@ -68,28 +61,17 @@ func (f FakeSocksConn) Reject() error { f.rejected = true return nil } -func (f FakeSocksConn) Grant(addr *net.TCPAddr) error { - return nil -} - -type FakeSnowflakeJar struct { - toRelease *webRTCConn -} +func (f FakeSocksConn) Grant(addr *net.TCPAddr) error { return nil } -func (f FakeSnowflakeJar) Release() *webRTCConn { - return nil -} +type FakePeers struct{ toRelease *webRTCConn } -func (f FakeSnowflakeJar) Collect() (*webRTCConn, error) { - return nil, nil -} +func (f FakePeers) Collect() error { return nil } +func (f FakePeers) Pop() *webRTCConn { return nil } func TestSnowflakeClient(t *testing.T) { - - Convey("WebRTC ConnectLoop", t, func() { - + SkipConvey("WebRTC ConnectLoop", t, func() { Convey("WebRTC ConnectLoop continues until capacity of 1.\n", func() { - snowflakes := NewSnowflakeJar(1) + snowflakes := NewPeers(1) snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) @@ -102,7 +84,7 @@ func TestSnowflakeClient(t *testing.T) { }) Convey("WebRTC ConnectLoop continues until capacity of 3.\n", func() { - snowflakes := NewSnowflakeJar(3) + snowflakes := NewPeers(3) snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) @@ -115,7 +97,7 @@ func TestSnowflakeClient(t *testing.T) { }) Convey("WebRTC ConnectLoop continues filling when Snowflakes disconnect.\n", func() { - snowflakes := NewSnowflakeJar(3) + snowflakes := NewPeers(3) snowflakes.Tongue = FakeDialer{} go ConnectLoop(snowflakes) @@ -135,17 +117,67 @@ func TestSnowflakeClient(t *testing.T) { }) }) + Convey("Peers", t, func() { + Convey("Can construct", func() { + p := NewPeers(1) + So(p.capacity, ShouldEqual, 1) + So(p.current, ShouldEqual, nil) + So(p.snowflakeChan, ShouldNotBeNil) + So(cap(p.snowflakeChan), ShouldEqual, 1) + }) + + Convey("Collecting a Snowflake requires a Tongue.", func() { + p := NewPeers(1) + err := p.Collect() + So(err, ShouldNotBeNil) + So(p.Count(), ShouldEqual, 0) + // Set the dialer so that collection is possible. + p.Tongue = FakeDialer{} + err = p.Collect() + So(err, ShouldBeNil) + So(p.Count(), ShouldEqual, 1) + // S + err = p.Collect() + }) + + Convey("Collection continues until capacity.", func() { + c := 5 + p := NewPeers(c) + p.Tongue = FakeDialer{} + // Fill up to capacity. + for i := 0 ; i < c ; i++ { + fmt.Println("Adding snowflake ", i) + err := p.Collect() + So(err, ShouldBeNil) + So(p.Count(), ShouldEqual, i + 1) + } + // But adding another gives an error. + So(p.Count(), ShouldEqual, c) + err := p.Collect() + So(err, ShouldNotBeNil) + So(p.Count(), ShouldEqual, c) + + // But popping allows it to continue. + s := p.Pop() + So(s, ShouldNotBeNil) + So(p.Count(), ShouldEqual, c) + + // err = p.Collect() + // So(err, ShouldNotBeNil) + // So(p.Count(), ShouldEqual, c) + }) + }) + Convey("Snowflake", t, func() { SkipConvey("Handler Grants correctly", func() { socks := &FakeSocksConn{} - snowflakes := &FakeSnowflakeJar{} + snowflakes := &FakePeers{} So(socks.rejected, ShouldEqual, false) snowflakes.toRelease = nil handler(socks, snowflakes) So(socks.rejected, ShouldEqual, true) - }) Convey("WebRTC Connection", func() { diff --git a/client/interfaces.go b/client/interfaces.go index 80a2ba3..ba49a92 100644 --- a/client/interfaces.go +++ b/client/interfaces.go @@ -1,30 +1,36 @@ +// In the Client context, "Snowflake" refers to a remote browser proxy. package main import ( "net" ) -// Interface for collecting and releasing snowflakes. -type SnowflakeCollector interface { - Collect() (*webRTCConn, error) - Release() *webRTCConn -} - -// Interface for catching those wild Snowflakes. +// Interface for catching Snowflakes. (aka the remote dialer) type Tongue interface { Catch() (*webRTCConn, error) } -// Interface which primarily adapts to goptlib's SocksConn struct. +// Interface for collecting some number of Snowflakes, for passing along +// ultimately to the SOCKS handler. +type SnowflakeCollector interface { + + // Add a Snowflake to the collection. + // Implementation should decide how to connect and maintain the webRTCConn. + Collect() error + + // Remove and return the most available Snowflake from the collection. + Pop() *webRTCConn +} + +// Interface to adapt to goptlib's SocksConn struct. type SocksConnector interface { Grant(*net.TCPAddr) error Reject() error net.Conn } -// Interface for the Snowflake's transport. -// (Specifically, webrtc.DataChannel) -type SnowflakeChannel interface { +// Interface for the Snowflake's transport. (Typically just webrtc.DataChannel) +type SnowflakeDataChannel interface { Send([]byte) Close() error } diff --git a/client/peers.go b/client/peers.go new file mode 100644 index 0000000..769174b --- /dev/null +++ b/client/peers.go @@ -0,0 +1,91 @@ +package main + +import ( + "errors" + "fmt" + "log" +) + +// Container which keeps track of multiple WebRTC remote peers. +// Implements |SnowflakeCollector|. +// +// Maintaining a set of pre-connected Peers with fresh but inactive datachannels +// allows allows rapid recovery when the current WebRTC Peer disconnects. +// +// Note: For now, only one remote can be active at any given moment. +// This is a property of Tor circuits & its current multiplexing constraints, +// but could be updated if that changes. +// (Also, this constraint does not necessarily apply to the more generic PT +// version of Snowflake) +type Peers struct { + Tongue + BytesLogger + + snowflakeChan chan *webRTCConn + current *webRTCConn + capacity int + // TODO: Probably not necessary. + maxedChan chan struct{} +} + +// Construct a fresh container of remote peers. +func NewPeers(max int) *Peers { + p := &Peers{capacity: max, current: nil} + // Use buffered go channel to pass new snowflakes onwards to the SOCKS handler. + p.snowflakeChan = make(chan *webRTCConn, max) + p.maxedChan = make(chan struct{}, 1) + return p +} + +// TODO: Needs fixing. +func (p *Peers) Count() int { + count := 0 + if p.current != nil { + count = 1 + } + return count + len(p.snowflakeChan) +} + +// As part of |SnowflakeCollector| interface. +func (p *Peers) Collect() error { + if p.Count() >= p.capacity { + s := fmt.Sprintf("At capacity [%d/%d]", p.Count(), p.capacity) + p.maxedChan <- struct{}{} + return errors.New(s) + } + // Engage the Snowflake Catching interface, which must be available. + if nil == p.Tongue { + return errors.New("Missing Tongue to catch Snowflakes with.") + } + connection, err := p.Tongue.Catch() + if nil == connection || nil != err { + return err + } + // Use the same rate-limited traffic logger to keep consistency. + connection.BytesLogger = p.BytesLogger + p.snowflakeChan <- connection + return nil +} + +// As part of |SnowflakeCollector| interface. +func (p *Peers) Pop() *webRTCConn { + // Blocks until an available snowflake appears. + snowflake, ok := <-p.snowflakeChan + if !ok { + return nil + } + p.current = snowflake + snowflake.BytesLogger = p.BytesLogger + return snowflake +} + +// Close all remote peers. +func (p *Peers) End() { + log.Printf("WebRTC: interruped") + if nil != p.current { + p.current.Close() + } + for r := range p.snowflakeChan { + r.Close() + } +} diff --git a/client/snowflake.go b/client/snowflake.go index cd7f151..f8edc2a 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -1,12 +1,10 @@ // Client transport plugin for the Snowflake pluggable transport. -// In the Client context, "Snowflake" refers to a remote browser proxy. package main import ( "bufio" "errors" "flag" - "fmt" "io" "log" "net" @@ -50,81 +48,12 @@ func copyLoop(a, b net.Conn) { log.Println("copy loop ended") } -// Collect and track available snowflakes. (Implements SnowflakeCollector) -// Right now, it is only possible to use one active remote in a circuit. -// This can be updated once multiplexed transport on a single circuit is available. -// Keeping multiple WebRTC connections available allows for quicker recovery when -// the current snowflake disconnects. -type SnowflakeJar struct { - Tongue - BytesLogger - - snowflakeChan chan *webRTCConn - current *webRTCConn - capacity int - maxedChan chan struct{} -} - -func NewSnowflakeJar(max int) *SnowflakeJar { - p := &SnowflakeJar{capacity: max} - p.snowflakeChan = make(chan *webRTCConn, max) - p.maxedChan = make(chan struct{}, 1) - return p -} - -// Establish connection to some remote WebRTC peer, and keep it available for -// later. -func (jar *SnowflakeJar) Collect() (*webRTCConn, error) { - if jar.Count() >= jar.capacity { - s := fmt.Sprintf("At capacity [%d/%d]", jar.Count(), jar.capacity) - jar.maxedChan <- struct{}{} - return nil, errors.New(s) - } - snowflake, err := jar.Catch() - if err != nil { - return nil, err - } - jar.snowflakeChan <- snowflake - return snowflake, nil -} - -// Prepare and present an available remote WebRTC peer for active use. -func (jar *SnowflakeJar) Release() *webRTCConn { - snowflake, ok := <-jar.snowflakeChan - if !ok { - return nil - } - jar.current = snowflake - snowflake.BytesLogger = jar.BytesLogger - return snowflake -} - -// TODO: Needs fixing. -func (p *SnowflakeJar) Count() int { - count := 0 - if p.current != nil { - count = 1 - } - return count + len(p.snowflakeChan) -} - -// Close all remote peers. -func (p *SnowflakeJar) End() { - log.Printf("WebRTC: interruped") - if nil != p.current { - p.current.Close() - } - for r := range p.snowflakeChan { - r.Close() - } -} - // Maintain |SnowflakeCapacity| number of available WebRTC connections, to // transfer to the Tor SOCKS handler when needed. func ConnectLoop(snowflakes SnowflakeCollector) { for { - s, err := snowflakes.Collect() - if nil == s || nil != err { + err := snowflakes.Collect() + if nil != err { log.Println("WebRTC Error:", err, " Retrying in", ReconnectTimeout, "seconds...") // Failed collections get a timeout. @@ -163,8 +92,8 @@ func handler(socks SocksConnector, snowflakes SnowflakeCollector) error { defer func() { handlerChan <- -1 }() - // Wait for an available WebRTC remote... - snowflake := snowflakes.Release() + // Obtain an available WebRTC remote. May block. + snowflake := snowflakes.Pop() if nil == snowflake { socks.Reject() return errors.New("handler: Received invalid Snowflake") @@ -247,10 +176,10 @@ func main() { // Prepare WebRTC SnowflakeCollector and the Broker, then accumulate connections. // TODO: Expose remote peer capacity as a flag? - snowflakes := NewSnowflakeJar(SnowflakeCapacity) + snowflakes := NewPeers(SnowflakeCapacity) broker := NewBrokerChannel(brokerURL, frontDomain, CreateBrokerTransport()) - snowflakes.Tongue = WebRTCDialer{broker} + snowflakes.Tongue = NewWebRTCDialer(broker) // Use a real logger for traffic. snowflakes.BytesLogger = &BytesSyncLogger{ diff --git a/client/webrtc.go b/client/webrtc.go index 41642be..2466a1d 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -14,6 +14,14 @@ import ( // Implements the |Tongue| interface to catch snowflakes, using a BrokerChannel. type WebRTCDialer struct { *BrokerChannel + webrtcConfig *webrtc.Configuration +} + +func NewWebRTCDialer(broker *BrokerChannel) *WebRTCDialer { + return &WebRTCDialer{ + broker, + webrtc.NewConfiguration(iceServers...), + } } // Initialize a WebRTC Connection by signaling through the broker. @@ -33,7 +41,7 @@ func (w WebRTCDialer) Catch() (*webRTCConn, error) { type webRTCConn struct { config *webrtc.Configuration pc *webrtc.PeerConnection - snowflake SnowflakeChannel // Holds the WebRTC DataChannel. + snowflake SnowflakeDataChannel // Holds the WebRTC DataChannel. broker *BrokerChannel offerChannel chan *webrtc.SessionDescription

1 0

[snowflake/master] expose multiplex capacity as flag, un-global some more
by serene＠torproject.org 12 Jun '16

12 Jun '16

commit b6f15a8d5c206829a694ab79c7bbdd1ed4c68a96 Author: Serene Han <keroserene+git(a)gmail.com> Date: Sun Jun 12 00:20:54 2016 -0700 expose multiplex capacity as flag, un-global some more --- client/peers.go | 2 +- client/rendezvous.go | 2 ++ client/snowflake.go | 28 +++++++++++++--------------- client/torrc | 3 ++- client/webrtc.go | 6 ++---- 5 files changed, 20 insertions(+), 21 deletions(-) diff --git a/client/peers.go b/client/peers.go index 57570bf..8aeb838 100644 --- a/client/peers.go +++ b/client/peers.go @@ -30,7 +30,7 @@ type Peers struct { // Construct a fresh container of remote peers. func NewPeers(max int) *Peers { p := &Peers{capacity: max} - // Use buffered go channel to pass new snowflakes onwards to the SOCKS handler. + // Use buffered go channel to pass snowflakes onwards to the SOCKS handler. p.snowflakeChan = make(chan *webRTCConn, max) p.activePeers = list.New() return p diff --git a/client/rendezvous.go b/client/rendezvous.go index 85549d3..fbb75dd 100644 --- a/client/rendezvous.go +++ b/client/rendezvous.go @@ -63,6 +63,8 @@ func NewBrokerChannel(broker string, front string, transport http.RoundTripper) // with an SDP answer from a designated remote WebRTC peer. func (bc *BrokerChannel) Negotiate(offer *webrtc.SessionDescription) ( *webrtc.SessionDescription, error) { + log.Println("Negotiating via BrokerChannel...\nTarget URL: ", + bc.Host, "\nFront URL: ", bc.url.Host) data := bytes.NewReader([]byte(offer.Serialize())) // Suffix with broker's client registration handler. request, err := http.NewRequest("POST", bc.url.String()+"client", data) diff --git a/client/snowflake.go b/client/snowflake.go index aa0e470..1c17642 100644 --- a/client/snowflake.go +++ b/client/snowflake.go @@ -21,12 +21,10 @@ import ( var ptInfo pt.ClientInfo const ( - ReconnectTimeout = 10 - SnowflakeCapacity = 1 + ReconnectTimeout = 10 + DefaultSnowflakeCapacity = 1 ) -var brokerURL string -var frontDomain string var iceServers IceServerList // When a connection handler starts, +1 is written to this channel; when it @@ -148,16 +146,18 @@ func main() { log.SetOutput(logFile) log.Println("\nStarting Snowflake Client...") - flag.StringVar(&brokerURL, "url", "", "URL of signaling broker") - flag.StringVar(&frontDomain, "front", "", "front domain") + brokerURL := flag.String("url", "", "URL of signaling broker") + frontDomain := flag.String("front", "", "front domain") flag.Var(&iceServers, "ice", "comma-separated list of ICE servers") + max := flag.Int("max", DefaultSnowflakeCapacity, + "capacity for number of multiplexed WebRTC peers") flag.Parse() // TODO: Maybe just get rid of copy-paste option entirely. - if "" != brokerURL { - log.Println("Rendezvous using Broker at: ", brokerURL) - if "" != frontDomain { - log.Println("Domain fronting using:", frontDomain) + if "" != *brokerURL { + log.Println("Rendezvous using Broker at: ", *brokerURL) + if "" != *frontDomain { + log.Println("Domain fronting using:", *frontDomain) } } else { log.Println("No HTTP signaling detected. Waiting for a \"signal\" pipe...") @@ -176,11 +176,9 @@ func main() { go readSignalingMessages(signalFile) } - // Prepare WebRTC SnowflakeCollector and the Broker, then accumulate connections. - // TODO: Expose remote peer capacity as a flag? - snowflakes := NewPeers(SnowflakeCapacity) - - broker := NewBrokerChannel(brokerURL, frontDomain, CreateBrokerTransport()) + // Prepare WebRTC SnowflakeCollector, Broker, then accumulate connections. + snowflakes := NewPeers(*max) + broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport()) snowflakes.Tongue = NewWebRTCDialer(broker) // Use a real logger for traffic. diff --git a/client/torrc b/client/torrc index c4af61f..d066454 100644 --- a/client/torrc +++ b/client/torrc @@ -4,6 +4,7 @@ DataDirectory datadir ClientTransportPlugin snowflake exec ./client \ -url https://snowflake-reg.appspot.com/ \ -front www.google.com \ --ice stun:stun.l.google.com:19302 +-ice stun:stun.l.google.com:19302 \ +-max 1 Bridge snowflake 0.0.3.0:1 diff --git a/client/webrtc.go b/client/webrtc.go index 87a1d19..c978f12 100644 --- a/client/webrtc.go +++ b/client/webrtc.go @@ -264,12 +264,10 @@ func (c *webRTCConn) establishDataChannel() error { } func (c *webRTCConn) sendOfferToBroker() { - if "" == brokerURL { + if nil == c.broker { return } offer := c.pc.LocalDescription() - log.Println("Sending offer via BrokerChannel...\nTarget URL: ", brokerURL, - "\nFront URL: ", frontDomain) answer, err := c.broker.Negotiate(offer) if nil != err || nil == answer { log.Printf("BrokerChannel Error: %s", err) @@ -284,7 +282,7 @@ func (c *webRTCConn) exchangeSDP() error { select { case offer := <-c.offerChannel: // Display for copy-paste, when no broker available. - if "" == brokerURL { + if nil == c.broker { log.Printf("Please Copy & Paste the following to the peer:") log.Printf("----------------") log.Printf("\n" + offer.Serialize() + "\n")

1 0

[translation/tails-misc_completed] Update translations for tails-misc_completed
by translation＠torproject.org 12 Jun '16

12 Jun '16

commit f17ee3d75df7c40a02fddb6333e369ae2551b1c0 Author: Translation commit bot <translation(a)torproject.org> Date: Sun Jun 12 17:46:30 2016 +0000 Update translations for tails-misc_completed --- ru.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ru.po b/ru.po index 146c4c6..d071bc9 100644 --- a/ru.po +++ b/ru.po @@ -24,8 +24,8 @@ msgid "" msgstr "" "Project-Id-Version: The Tor Project\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2016-05-25 20:25+0200\n" -"PO-Revision-Date: 2016-05-27 10:12+0000\n" +"POT-Creation-Date: 2016-06-06 14:26+0200\n" +"PO-Revision-Date: 2016-06-12 17:34+0000\n" "Last-Translator: carolyn <carolyn(a)anhalt.org>\n" "Language-Team: Russian (http://www.transifex.com/otf/torproject/language/ru/)\n" "MIME-Version: 1.0\n"

1 0

[translation/tails-misc] Update translations for tails-misc
by translation＠torproject.org 12 Jun '16

12 Jun '16

commit bc5ff1ce17e95bbf4ca536ccbca538e925d11281 Author: Translation commit bot <translation(a)torproject.org> Date: Sun Jun 12 17:46:24 2016 +0000 Update translations for tails-misc --- ru.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ru.po b/ru.po index 146c4c6..d071bc9 100644 --- a/ru.po +++ b/ru.po @@ -24,8 +24,8 @@ msgid "" msgstr "" "Project-Id-Version: The Tor Project\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2016-05-25 20:25+0200\n" -"PO-Revision-Date: 2016-05-27 10:12+0000\n" +"POT-Creation-Date: 2016-06-06 14:26+0200\n" +"PO-Revision-Date: 2016-06-12 17:34+0000\n" "Last-Translator: carolyn <carolyn(a)anhalt.org>\n" "Language-Team: Russian (http://www.transifex.com/otf/torproject/language/ru/)\n" "MIME-Version: 1.0\n"

1 0

[ooni-probe/master] Fix/remove meek google test (#520)
by art＠torproject.org 12 Jun '16

12 Jun '16

commit bc60f74649626dbb37511e1ca47c80624efd2dd5 Author: anadahz <anadahz(a)users.noreply.github.com> Date: Fri Jun 3 18:20:44 2016 +0000 Fix/remove meek google test (#520) * Remove meek google servers from the test, update doc meek-google has not been working since May 13, 2016. It is not because censors figured out how to block it, but because Google Cloud Platform suspended the reflector web application (https://meek-reflect.appspot.com/) https://lists.torproject.org/pipermail/tor-talk/2016-June/041057.html --- docs/source/tests/meek_fronted_requests.rst | 36 ------------------------- ooni/nettests/blocking/meek_fronted_requests.py | 4 +-- 2 files changed, 1 insertion(+), 39 deletions(-) diff --git a/docs/source/tests/meek_fronted_requests.rst b/docs/source/tests/meek_fronted_requests.rst index b865e18..5bade82 100644 --- a/docs/source/tests/meek_fronted_requests.rst +++ b/docs/source/tests/meek_fronted_requests.rst @@ -138,39 +138,3 @@ success: true test_runtime: 0.4580512046813965 test_start_time: 1444932097.0 ... ---- -agent: agent -input: [www.google.com, meek-reflect.appspot.com] -requests: -- request: - body: null - headers: - - - Host - - [meek-reflect.appspot.com] - method: GET - tor: {is_tor: false} - url: https://www.google.com - response: - body: "I\u2019m just a happy little web server.\n" - code: 200 - headers: - - - Alternate-Protocol - - ['443:quic,p=1'] - - - Content-Length - - ['38'] - - - Server - - [Google Frontend] - - - Connection - - [close] - - - Date - - ['Thu, 15 Oct 2015 20:01:38 GMT'] - - - Alt-Svc - - ['quic=":443"; p="1"; ma=604800'] - - - Content-Type - - [text/plain; charset=utf-8] -socksproxy: null -success: true -test_runtime: 0.5862560272216797 -test_start_time: 1444932097.0 -... - ... diff --git a/ooni/nettests/blocking/meek_fronted_requests.py b/ooni/nettests/blocking/meek_fronted_requests.py index 960d971..a0088f5 100644 --- a/ooni/nettests/blocking/meek_fronted_requests.py +++ b/ooni/nettests/blocking/meek_fronted_requests.py @@ -23,7 +23,6 @@ class meekTest(httpt.HTTPTest): and response with: "I’m just a happy little web server.\n". The input file should be formatted as (one per line): "domainName:hostHeader" - www.google.com:meek-reflect.appspot.com ajax.aspnetcdn.com:az668014.vo.msecnd.net a0.awsstatic.com:d2zfqthxsdq309.cloudfront.net @@ -37,8 +36,7 @@ class meekTest(httpt.HTTPTest): inputFile = ['file', 'f', None, "File containing the domainName:hostHeader combinations to\ be tested, one per line."] - inputs = [('www.google.com', 'meek-reflect.appspot.com'), - ('ajax.aspnetcdn.com', 'az668014.vo.msecnd.net'), + inputs = [('ajax.aspnetcdn.com', 'az668014.vo.msecnd.net'), ('a0.awsstatic.com', 'd2zfqthxsdq309.cloudfront.net')] requiresRoot = False

1 0