├── .gitignore
├── Dockerfile
├── LICENSE
├── Makefile
├── README
├── cmd
    └── ww
    │   ├── file.go
    │   ├── main.go
    │   ├── pipe.go
    │   └── server.go
├── go.mod
├── go.sum
├── web
    ├── icon.svg
    ├── icon128.png
    ├── icon16.png
    ├── icon192.png
    ├── icon48.png
    ├── icon512.png
    ├── icon96.png
    ├── index.html
    ├── main.js
    ├── main.ts
    ├── manifest.json
    ├── pwa.json
    ├── space.svg
    ├── style.css
    ├── sw.js
    ├── sw.ts
    ├── webwormhole.go
    ├── ww.js
    └── ww.ts
├── webdriver
    ├── Dockerfile
    └── smoke.py
├── wordlist
    ├── wordlist.go
    └── wordlist_test.go
└── wormhole
    └── dial.go


/.gitignore:
--------------------------------------------------------------------------------
1 | /web/webwormhole.wasm
2 | /web/wasm_exec.js
3 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM node:slim as jsbuild
 2 | RUN npm install -g typescript prettier
 3 | WORKDIR /src
 4 | 
 5 | FROM golang:alpine as gobuild
 6 | WORKDIR /src
 7 | COPY go.mod go.sum ./
 8 | RUN go mod download
 9 | COPY . /src
10 | RUN GOOS=js GOARCH=wasm go build -o ./web/webwormhole.wasm ./web
11 | RUN cp $(go env GOROOT)/misc/wasm/wasm_exec.js ./web/wasm_exec.js
12 | RUN go build ./cmd/ww
13 | 
14 | FROM alpine:latest
15 | RUN apk --no-cache add ca-certificates
16 | COPY --from=gobuild /src/ww /bin
17 | COPY --from=gobuild /src/web /web
18 | WORKDIR /
19 | ENTRYPOINT ["/bin/ww", "server"]
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright 2020 Salman Aljammaz. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions
 5 | are met:
 6 | 
 7 | 1. Redistributions of source code must retain the above copyright
 8 | notice, this list of conditions and the following disclaimer.
 9 | 
10 | 2. Redistributions in binary form must reproduce the above copyright
11 | notice, this list of conditions and the following disclaimer in the
12 | documentation and/or other materials provided with the distribution.
13 | 
14 | 3. Neither the name of the copyright holder nor the names of its
15 | contributors may be used to endorse or promote products derived
16 | from this software without specific prior written permission.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 | FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 | COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 | ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 | POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | .PHONY: wasm
 2 | wasm:
 3 | 	GOOS=js GOARCH=wasm go build -o ./web/webwormhole.wasm ./web
 4 | 	cp $(shell go env GOROOT)/lib/wasm/wasm_exec.js ./web/wasm_exec.js
 5 | 
 6 | .PHONY: webwormhole-ext.zip
 7 | webwormhole-ext.zip: wasm
 8 | 	zip -j webwormhole-ext.zip ./web/* -x '*.git*' '*.go' '*Dockerfile'
 9 | 
10 | .PHONY: webwormhole-src.zip
11 | webwormhole-src.zip:
12 | 	zip -r -FS webwormhole-src.zip  * -x '*.git*' webwormhole-src.zip webwormhole-ext.zip
13 | 
14 | .PHONY: all
15 | all: webwormhole-ext.zip
16 | 
17 | .PHONY: fmt
18 | fmt:
19 | 	prettier -w --use-tabs web/*.ts
20 | 	go fmt ./...
21 | 
22 | .PHONY: js
23 | js:
24 | 	tsc -T ES2018 --strict web/ww.ts
25 | 	tsc -T ES2018 --strict web/sw.ts
26 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | THIS PROJECT IS STILL IN EARLY DEVELOPMENT IT USES EXPERIMENTAL
  2 | CRYPTOGRAPHIC LIBRARIES AND IT HAS NOT HAD ANY KIND OF SECURITY
  3 | OR CRYPTOGRAPHY REVIEW THIS SOFTWARE MIGHT BE BROKEN AND UNSAFE
  4 | 
  5 | 	https://xkcd.com/949/
  6 | 
  7 | WebWormhole creates ephemeral pipes between computers to send files
  8 | or other data. Try it at https://webwormhole.io or on the command
  9 | line.
 10 | 
 11 | On one computer the tool generates a one-time code:
 12 | 
 13 | 	$ cat hello.txt
 14 | 	hello, world
 15 | 	$ ww send hello.txt
 16 | 	east-pep-aloe
 17 | 
 18 | On another use the code to establish a connection:
 19 | 
 20 | 	$ ww receive east-pep-aloe
 21 | 	$ cat hello.txt
 22 | 	hello, world
 23 | 
 24 | To install the command line tool:
 25 | 
 26 | 	$ go install webwormhole.io/cmd/ww@latest
 27 | 
 28 | This requires Go 1.13 or newer.
 29 | 
 30 | To run the signalling server you need to compile the WebAssembly
 31 | files first.
 32 | 
 33 | 	$ make wasm
 34 | 	$ ww server -https= -http=localhost:8000
 35 | 
 36 | To package the browser extension for Firefox or Chrome:
 37 | 
 38 | 	$ make webwormhole-ext.zip
 39 | 
 40 | WebWormhole is inspired by and uses a model very similar to that
 41 | of Magic Wormhole.
 42 | 
 43 | 	https://github.com/warner/magic-wormhole
 44 | 
 45 | It differs in that it uses WebRTC to make its connections. This
 46 | allows us to make use of WebRTC's NAT traversal tricks, as well as
 47 | the fact that it can be used in browsers. The exchange of session
 48 | descriptions (offers and answers) is protected by PAKE (we use
 49 | CPace) and a generated random password, similar to Magic Wormhole.
 50 | The session descriptions include the fingerprints of the DTLS
 51 | certificates that WebRTC uses to secure its communications.
 52 | 
 53 | The author operates the signalling server at webwormhole.io, its
 54 | alias wrmhl.link, and a relay server. These are free to use but
 55 | come with no SLAs or any guarantees of uptime. They facilitate
 56 | establishing connections between peers, but do not handle any
 57 | transferred data in cleartext.
 58 | 
 59 | The protocol does not need to trust the signalling server to maintain
 60 | the confidentiality of the files transferred. However, the convenience
 61 | of using the web client directly on webwormhole.io comes at the
 62 | cost of having to trust the code it serves. If the server is ever
 63 | compromised it can be used inject malicious code that undermines
 64 | the security of the client. To mitigate this, you can have more
 65 | control over which version of the client you run by using the command
 66 | line client or the browser extension. The extension is identical
 67 | to the web client, but packaged for Chrome and Firefox, loads no
 68 | remote code, and requires no permissions:
 69 | 
 70 | 	https://addons.mozilla.org/firefox/addon/webwormhole/
 71 | 	https://chrome.google.com/webstore/detail/jhombkhjanncdalcbcahinpjoacaiidn
 72 | 
 73 | Unless otherwise noted, the source files in this repository are
 74 | distributed under the BSD-style license found in the LICENSE file.
 75 | 
 76 | Frequently asked questions
 77 | 
 78 | Is it compatible with magic-wormhole?
 79 | 
 80 | 	It is not. Maybe one day.
 81 | 
 82 | 	This project started as a UI for magic-wormhole, but drifted
 83 | 	away when I wanted to experiment with the PAKE used, the
 84 | 	protocol, and the word lists.
 85 | 
 86 | Why CPace and not another PAKE algorithm?
 87 | 
 88 | 	CPace and PAKE2 were the finalists for CFRG PAKE selection
 89 | 	process (https://github.com/cfrg/pake-selection), so it was
 90 | 	going to be one of the two.
 91 | 
 92 | 	CPace (https://tools.ietf.org/id/draft-haase-cpace-01.html)
 93 | 	looked nice and simple to implement, and there wasn't a
 94 | 	CPace Go package at the time, so it was a good opportunity
 95 | 	and a learning exercise to write one. I ended up nerd-sniping
 96 | 	Filippo instead and he beat me to write filippo.io/cpace.
 97 | 
 98 | Why not the PGP word list?
 99 | 
100 | 	The PGP word list (https://en.wikipedia.org/wiki/PGP_word_list)
101 | 	is quite good as far as unambiguity goes. However, a few
102 | 	word combinations do make some unsavoury phrases. I switched
103 | 	to a word list that is more agreeable.
104 | 
105 | 	Also, it would be nice to experiment with localised word
106 | 	lists.
107 | 
108 | Don't you have to trust the web server anyway? What's the point of
109 | the PAKE?
110 | 
111 | 	Yes and no. The application itself, because of the PAKE,
112 | 	does not need to trust the signalling server. You can install
113 | 	the command line tool, the browser extension, or host the
114 | 	web application's files yourself and not have to trust the
115 | 	signalling server at all. There's also a mobile app version
116 | 	in the works.
117 | 
118 | 	The web version hosted on webwormhole.io exists as a middle
119 | 	ground between convenience and security. Like any other
120 | 	website you visit, you do have to trust it's not running
121 | 	any malicious code in your browser.
122 | 


--------------------------------------------------------------------------------
/cmd/ww/file.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"flag"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"os"
  9 | 	"path/filepath"
 10 | )
 11 | 
 12 | const (
 13 | 	// msgChunkSize is the maximum size of a WebRTC DataChannel message.
 14 | 	// 64k is okay for most modern browsers, 32 is conservative.
 15 | 	msgChunkSize = 32 << 10
 16 | )
 17 | 
 18 | type header struct {
 19 | 	Name string `json:"name",omitempty`
 20 | 	Size int    `json:"size",omitempty`
 21 | 	Type string `json:"type",omitempty`
 22 | }
 23 | 
 24 | func receive(args ...string) {
 25 | 	set := flag.NewFlagSet(args[0], flag.ExitOnError)
 26 | 	set.Usage = func() {
 27 | 		fmt.Fprintf(set.Output(), "receive files\n\n")
 28 | 		fmt.Fprintf(set.Output(), "usage: %s %s [code]\n\n", os.Args[0], args[0])
 29 | 		fmt.Fprintf(set.Output(), "flags:\n")
 30 | 		set.PrintDefaults()
 31 | 	}
 32 | 	length := set.Int("length", 2, "length of generated secret, if generating")
 33 | 	directory := set.String("dir", ".", "directory to put downloaded files")
 34 | 	set.Parse(args[1:])
 35 | 
 36 | 	if set.NArg() > 1 {
 37 | 		set.Usage()
 38 | 		os.Exit(2)
 39 | 	}
 40 | 	c := newConn(set.Arg(0), *length)
 41 | 
 42 | 	// TODO append number to existing filenames?
 43 | 
 44 | 	for {
 45 | 		// First message is the header. 1k should be enough.
 46 | 		buf := make([]byte, 1<<10)
 47 | 		n, err := c.Read(buf)
 48 | 		if err == io.EOF {
 49 | 			break
 50 | 		}
 51 | 		if err != nil {
 52 | 			fatalf("could not read file header: %v", err)
 53 | 		}
 54 | 		var h header
 55 | 		err = json.Unmarshal(buf[:n], &h)
 56 | 		if err != nil {
 57 | 			fatalf("could not decode file header: %v", err)
 58 | 		}
 59 | 
 60 | 		f, err := os.Create(filepath.Join(*directory, filepath.Clean("/"+h.Name)))
 61 | 		if err != nil {
 62 | 			fatalf("could not create output file %s: %v", h.Name, err)
 63 | 		}
 64 | 		fmt.Fprintf(set.Output(), "receiving %v... ", h.Name)
 65 | 		written, err := io.CopyBuffer(f, io.LimitReader(c, int64(h.Size)), make([]byte, msgChunkSize))
 66 | 		if err != nil {
 67 | 			fatalf("\ncould not save file: %v", err)
 68 | 		}
 69 | 		if written != int64(h.Size) {
 70 | 			fatalf("\nEOF before receiving all bytes: (%d/%d)", written, h.Size)
 71 | 		}
 72 | 		f.Close()
 73 | 		fmt.Fprintf(set.Output(), "done\n")
 74 | 	}
 75 | 	c.Close()
 76 | }
 77 | 
 78 | func send(args ...string) {
 79 | 	set := flag.NewFlagSet(args[0], flag.ExitOnError)
 80 | 	set.Usage = func() {
 81 | 		fmt.Fprintf(set.Output(), "send files\n\n")
 82 | 		fmt.Fprintf(set.Output(), "usage: %s %s [files]...\n\n", os.Args[0], args[0])
 83 | 		fmt.Fprintf(set.Output(), "flags:\n")
 84 | 		set.PrintDefaults()
 85 | 	}
 86 | 	length := set.Int("length", 2, "length of generated secret")
 87 | 	code := set.String("code", "", "use a wormhole code instead of generating one")
 88 | 	set.Parse(args[1:])
 89 | 
 90 | 	if set.NArg() < 1 {
 91 | 		set.Usage()
 92 | 		os.Exit(2)
 93 | 	}
 94 | 	c := newConn(*code, *length)
 95 | 
 96 | 	for _, filename := range set.Args() {
 97 | 		f, err := os.Open(filename)
 98 | 		if err != nil {
 99 | 			fatalf("could not open file %s: %v", filename, err)
100 | 		}
101 | 		info, err := f.Stat()
102 | 		if err != nil {
103 | 			fatalf("could not stat file %s: %v", filename, err)
104 | 		}
105 | 		h, err := json.Marshal(header{
106 | 			Name: filepath.Base(filepath.Clean(filename)),
107 | 			Size: int(info.Size()),
108 | 		})
109 | 		if err != nil {
110 | 			fatalf("failed to marshal json: %v", err)
111 | 		}
112 | 		_, err = c.Write(h)
113 | 		if err != nil {
114 | 			fatalf("could not send file header: %v", err)
115 | 		}
116 | 		fmt.Fprintf(set.Output(), "sending %v... ", filepath.Base(filepath.Clean(filename)))
117 | 		written, err := io.CopyBuffer(c, f, make([]byte, msgChunkSize))
118 | 		if err != nil {
119 | 			fatalf("\ncould not send file: %v", err)
120 | 		}
121 | 		if written != info.Size() {
122 | 			fatalf("\nEOF before sending all bytes: (%d/%d)", written, info.Size())
123 | 		}
124 | 		f.Close()
125 | 		fmt.Fprintf(set.Output(), "done\n")
126 | 	}
127 | 	c.Close()
128 | }
129 | 


--------------------------------------------------------------------------------
/cmd/ww/main.go:
--------------------------------------------------------------------------------
  1 | // Command ww moves files and other data over WebRTC.
  2 | //
  3 | // Install using:
  4 | //
  5 | //	go install webwormhole.io/cmd/ww@latest
  6 | package main
  7 | 
  8 | import (
  9 | 	crand "crypto/rand"
 10 | 	"flag"
 11 | 	"fmt"
 12 | 	"io"
 13 | 	"net/url"
 14 | 	"os"
 15 | 	"strconv"
 16 | 
 17 | 	"rsc.io/qr"
 18 | 	"webwormhole.io/wordlist"
 19 | 	"webwormhole.io/wormhole"
 20 | )
 21 | 
 22 | var subcmds = map[string]func(args ...string){
 23 | 	"send":    send,
 24 | 	"receive": receive,
 25 | 	"pipe":    pipe,
 26 | 	"server":  server,
 27 | }
 28 | 
 29 | var (
 30 | 	verbose bool   = false
 31 | 	sigserv string = "https://webwormhole.io"
 32 | )
 33 | 
 34 | var stderr = flag.CommandLine.Output()
 35 | 
 36 | func usage() {
 37 | 	fmt.Fprintf(stderr, "webwormhole creates ephemeral pipes between computers.\n\n")
 38 | 	fmt.Fprintf(stderr, "usage:\n\n")
 39 | 	fmt.Fprintf(stderr, "  %s [flags] <command> [arguments]\n\n", os.Args[0])
 40 | 	fmt.Fprintf(stderr, "commands:\n")
 41 | 	for key := range subcmds {
 42 | 		fmt.Fprintf(stderr, "  %s\n", key)
 43 | 	}
 44 | 	fmt.Fprintf(stderr, "\nflags:\n")
 45 | 	flag.PrintDefaults()
 46 | }
 47 | 
 48 | func main() {
 49 | 	flag.BoolVar(&verbose, "verbose", LookupEnvOrBool("WW_VERBOSE", verbose), "verbose logging")
 50 | 	flag.StringVar(&sigserv, "signal", LookupEnvOrString("WW_SIGSERV", sigserv), "signalling server to use")
 51 | 	flag.Usage = usage
 52 | 	flag.Parse()
 53 | 	if flag.NArg() < 1 {
 54 | 		usage()
 55 | 		os.Exit(2)
 56 | 	}
 57 | 	if verbose {
 58 | 		wormhole.Verbose = true
 59 | 	}
 60 | 	cmd, ok := subcmds[flag.Arg(0)]
 61 | 	if !ok {
 62 | 		flag.Usage()
 63 | 		os.Exit(2)
 64 | 	}
 65 | 	cmd(flag.Args()...)
 66 | }
 67 | 
 68 | func fatalf(format string, v ...interface{}) {
 69 | 	fmt.Fprintf(stderr, format+"\n", v...)
 70 | 	os.Exit(1)
 71 | }
 72 | 
 73 | func newConn(code string, length int) *wormhole.Wormhole {
 74 | 	if code != "" {
 75 | 		// Join wormhole.
 76 | 		slot, pass := wordlist.Decode(code)
 77 | 		if pass == nil {
 78 | 			fatalf("could not decode password")
 79 | 		}
 80 | 		c, err := wormhole.Join(strconv.Itoa(slot), string(pass), sigserv)
 81 | 		if err == wormhole.ErrBadVersion {
 82 | 			fatalf(
 83 | 				"%s%s%s",
 84 | 				"the signalling server is running an incompatable version.\n",
 85 | 				"try upgrading the client:\n\n",
 86 | 				"    go get webwormhole.io/cmd/ww\n",
 87 | 			)
 88 | 		}
 89 | 		if err != nil {
 90 | 			fatalf("could not dial: %v", err)
 91 | 		}
 92 | 		if c.IsRelay() {
 93 | 			fmt.Fprintf(stderr, "connected: relay\n")
 94 | 		} else {
 95 | 			fmt.Fprintf(stderr, "connected: direct\n")
 96 | 		}
 97 | 		return c
 98 | 	}
 99 | 	// New wormhole.
100 | 	pass := make([]byte, length)
101 | 	if _, err := io.ReadFull(crand.Reader, pass); err != nil {
102 | 		fatalf("could not generate password: %v", err)
103 | 	}
104 | 	slotc := make(chan string)
105 | 	go func() {
106 | 		s := <-slotc
107 | 		slot, err := strconv.Atoi(s)
108 | 		if err != nil {
109 | 			fatalf("got invalid slot from signalling server: %v", s)
110 | 		}
111 | 		printcode(wordlist.Encode(slot, pass))
112 | 	}()
113 | 	c, err := wormhole.New(string(pass), sigserv, slotc)
114 | 	if err == wormhole.ErrBadVersion {
115 | 		fatalf(
116 | 			"%s%s%s",
117 | 			"the signalling server is running an incompatable version.\n",
118 | 			"try upgrading the client:\n\n",
119 | 			"    go get webwormhole.io/cmd/ww\n",
120 | 		)
121 | 	}
122 | 	if err != nil {
123 | 		fatalf("could not dial: %v", err)
124 | 	}
125 | 	if c.IsRelay() {
126 | 		fmt.Fprintf(stderr, "connected: relay\n")
127 | 	} else {
128 | 		fmt.Fprintf(stderr, "connected: direct\n")
129 | 	}
130 | 	return c
131 | }
132 | 
133 | func printcode(code string) {
134 | 	fmt.Fprintf(stderr, "%s\n", code)
135 | 	u, err := url.Parse(sigserv)
136 | 	if err != nil {
137 | 		return
138 | 	}
139 | 	u.Fragment = code
140 | 	qrcode, err := qr.Encode(u.String(), qr.L)
141 | 	if err != nil {
142 | 		return
143 | 	}
144 | 	for x := 0; x < qrcode.Size; x++ {
145 | 		fmt.Fprintf(stderr, "█")
146 | 	}
147 | 	fmt.Fprintf(stderr, "████████\n")
148 | 	for x := 0; x < qrcode.Size; x++ {
149 | 		fmt.Fprintf(stderr, "█")
150 | 	}
151 | 	fmt.Fprintf(stderr, "████████\n")
152 | 	for y := 0; y < qrcode.Size; y += 2 {
153 | 		fmt.Fprintf(stderr, "████")
154 | 		for x := 0; x < qrcode.Size; x++ {
155 | 			switch {
156 | 			case qrcode.Black(x, y) && qrcode.Black(x, y+1):
157 | 				fmt.Fprintf(stderr, " ")
158 | 			case qrcode.Black(x, y):
159 | 				fmt.Fprintf(stderr, "▄")
160 | 			case qrcode.Black(x, y+1):
161 | 				fmt.Fprintf(stderr, "▀")
162 | 			default:
163 | 				fmt.Fprintf(stderr, "█")
164 | 			}
165 | 		}
166 | 		fmt.Fprintf(stderr, "████\n")
167 | 	}
168 | 	for x := 0; x < qrcode.Size; x++ {
169 | 		fmt.Fprintf(stderr, "█")
170 | 	}
171 | 	fmt.Fprintf(stderr, "████████\n")
172 | 	for x := 0; x < qrcode.Size; x++ {
173 | 		fmt.Fprintf(stderr, "█")
174 | 	}
175 | 	fmt.Fprintf(stderr, "████████\n")
176 | 	fmt.Fprintf(stderr, "%s\n", u.String())
177 | }
178 | 
179 | func LookupEnvOrBool(key string, defaultVal bool) bool {
180 | 	if v, ok := os.LookupEnv(key); ok {
181 | 		val, err := strconv.ParseBool(v)
182 | 		if err != nil {
183 | 			fatalf("Cannot parse envvar: %s: %v", v, err)
184 | 		}
185 | 		return val
186 | 	}
187 | 	return defaultVal
188 | }
189 | 
190 | func LookupEnvOrString(key string, defaultVal string) string {
191 | 	if val, ok := os.LookupEnv(key); ok {
192 | 		return val
193 | 	}
194 | 	return defaultVal
195 | }
196 | 


--------------------------------------------------------------------------------
/cmd/ww/pipe.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"fmt"
 6 | 	"io"
 7 | 	"os"
 8 | )
 9 | 
10 | func pipe(args ...string) {
11 | 	set := flag.NewFlagSet(args[0], flag.ExitOnError)
12 | 	set.Usage = func() {
13 | 		fmt.Fprintf(set.Output(), "netcat-like pipe\n\n")
14 | 		fmt.Fprintf(set.Output(), "usage: %s %s [code]\n\n", os.Args[0], args[0])
15 | 		fmt.Fprintf(set.Output(), "flags:\n")
16 | 		set.PrintDefaults()
17 | 	}
18 | 	length := set.Int("length", 2, "length of generated secret, if generating")
19 | 	set.Parse(args[1:])
20 | 
21 | 	if set.NArg() > 1 {
22 | 		set.Usage()
23 | 		os.Exit(2)
24 | 	}
25 | 	c := newConn(set.Arg(0), *length)
26 | 
27 | 	done := make(chan struct{})
28 | 	// The recieve end of the pipe.
29 | 	go func() {
30 | 		_, err := io.CopyBuffer(os.Stdout, c, make([]byte, msgChunkSize))
31 | 		if err != nil {
32 | 			fatalf("could not write to stdout: %v", err)
33 | 		}
34 | 		done <- struct{}{}
35 | 	}()
36 | 	// The send end of the pipe.
37 | 	go func() {
38 | 		_, err := io.CopyBuffer(c, os.Stdin, make([]byte, msgChunkSize))
39 | 		if err != nil {
40 | 			fatalf("could not write to channel: %v", err)
41 | 		}
42 | 		done <- struct{}{}
43 | 	}()
44 | 	<-done
45 | 	c.Close()
46 | }
47 | 


--------------------------------------------------------------------------------
/cmd/ww/server.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | // This is the signalling server. It relays messages between peers wishing to connect.
  4 | 
  5 | import (
  6 | 	"context"
  7 | 	"crypto/hmac"
  8 | 	"crypto/sha1"
  9 | 	"crypto/tls"
 10 | 	"encoding/base64"
 11 | 	"encoding/json"
 12 | 	"flag"
 13 | 	"fmt"
 14 | 	"log"
 15 | 	"math/rand"
 16 | 	"net/http"
 17 | 	"os"
 18 | 	"strconv"
 19 | 	"strings"
 20 | 	"sync"
 21 | 	"time"
 22 | 
 23 | 	"github.com/NYTimes/gziphandler"
 24 | 	webrtc "github.com/pion/webrtc/v3"
 25 | 	"github.com/prometheus/client_golang/prometheus"
 26 | 	"github.com/prometheus/client_golang/prometheus/promhttp"
 27 | 	"golang.org/x/crypto/acme/autocert"
 28 | 	"nhooyr.io/websocket"
 29 | 	"webwormhole.io/wormhole"
 30 | )
 31 | 
 32 | // slotTimeout is the the maximum amount of time a client is allowed to
 33 | // hold a slot.
 34 | const slotTimeout = 12 * time.Hour
 35 | 
 36 | const importMeta = `<!doctype html>
 37 | <meta charset=utf-8>
 38 | <meta name="go-import" content="webwormhole.io git https://github.com/saljam/webwormhole">
 39 | <meta http-equiv="refresh" content="0;URL='https://github.com/saljam/webwormhole'">
 40 | `
 41 | 
 42 | const serviceWorkerPage = `You're not supposed to get this file or end up here.
 43 | 
 44 | This is a dummy URL is used by WebWormhole to help web browsers
 45 | efficiently download files from a WebRTC connection. It should be
 46 | handled entirely by a ServiceWorker running in your browser.
 47 | 
 48 | If you got this text instead of the file you expected to download,
 49 | it is possible your web browser doesn't fully support ServiceWorkers
 50 | but claims it does. Try a different web browser, and if that doesn't
 51 | work, please file a bug report.
 52 | `
 53 | 
 54 | var (
 55 | 	rendezvousCounter = prometheus.NewCounterVec(
 56 | 		prometheus.CounterOpts{
 57 | 			Namespace: "ww",
 58 | 			Name:      "rendezvous_attempts",
 59 | 			Help:      "Number of attempts to rendezvous using the signalling server.",
 60 | 		},
 61 | 		[]string{"result"},
 62 | 	)
 63 | 	iceCounter = prometheus.NewCounterVec(
 64 | 		prometheus.CounterOpts{
 65 | 			Namespace: "ww",
 66 | 			Name:      "webrtc_attempts",
 67 | 			Help:      "Number of reported ICE results sliced by ICE method used.",
 68 | 		},
 69 | 		[]string{"result", "method"},
 70 | 	)
 71 | 	protocolErrorCounter = prometheus.NewCounterVec(
 72 | 		prometheus.CounterOpts{
 73 | 			Namespace: "ww",
 74 | 			Name:      "protocol_errors",
 75 | 			Help:      "Number of bad requests to the signalling server.",
 76 | 		},
 77 | 		[]string{"kind"},
 78 | 	)
 79 | 	slotsGuage = prometheus.NewGauge(
 80 | 		prometheus.GaugeOpts{
 81 | 			Namespace: "ww",
 82 | 			Name:      "busy_slots",
 83 | 			Help:      "Number of currently busy slots.",
 84 | 		},
 85 | 	)
 86 | )
 87 | 
 88 | func init() {
 89 | 	prometheus.MustRegister(rendezvousCounter)
 90 | 	prometheus.MustRegister(iceCounter)
 91 | 	prometheus.MustRegister(protocolErrorCounter)
 92 | 	prometheus.MustRegister(slotsGuage)
 93 | }
 94 | 
 95 | // slots is a map of allocated slot numbers.
 96 | var slots = struct {
 97 | 	m map[string]chan *websocket.Conn
 98 | 	sync.RWMutex
 99 | }{m: make(map[string]chan *websocket.Conn)}
100 | 
101 | // turnSecret, turnServer, and stunServers are used to generate ICE config
102 | // and send it to clients as soon as they connect.
103 | var turnSecret string
104 | var turnServer string
105 | var stunServers []webrtc.ICEServer
106 | 
107 | // freeslot tries to find an available numeric slot, favouring smaller numbers.
108 | // This assume slots is locked.
109 | func freeslot() (slot string, ok bool) {
110 | 	// Assuming varint encoding, we first try for one byte. That's 7 bits in varint.
111 | 	for i := 0; i < 64; i++ {
112 | 		s := strconv.Itoa(rand.Intn(1 << 7))
113 | 		if _, ok := slots.m[s]; !ok {
114 | 			return s, true
115 | 		}
116 | 	}
117 | 	// Then try for two bytes. 11 bits.
118 | 	for i := 0; i < 1024; i++ {
119 | 		s := strconv.Itoa(rand.Intn(1 << 11))
120 | 		if _, ok := slots.m[s]; !ok {
121 | 			return s, true
122 | 		}
123 | 	}
124 | 	// Then try for three bytes. 16 bits.
125 | 	for i := 0; i < 2048; i++ {
126 | 		s := strconv.Itoa(rand.Intn(1 << 16))
127 | 		if _, ok := slots.m[s]; !ok {
128 | 			return s, true
129 | 		}
130 | 	}
131 | 	// Then try for four bytes. 21 bits.
132 | 	for i := 0; i < 2048; i++ {
133 | 		s := strconv.Itoa(rand.Intn(1 << 21))
134 | 		if _, ok := slots.m[s]; !ok {
135 | 			return s, true
136 | 		}
137 | 	}
138 | 	// Give up.
139 | 	return "", false
140 | }
141 | 
142 | // turnServers return the configured TURN server with HMAC-based ephemeral
143 | // credentials generated as described in:
144 | // https://tools.ietf.org/html/draft-uberti-behave-turn-rest-00
145 | func turnServers() []webrtc.ICEServer {
146 | 	if turnServer == "" {
147 | 		return nil
148 | 	}
149 | 	username := fmt.Sprintf("%d:wormhole", time.Now().Add(slotTimeout).Unix())
150 | 	mac := hmac.New(sha1.New, []byte(turnSecret))
151 | 	mac.Write([]byte(username))
152 | 	return []webrtc.ICEServer{{
153 | 		URLs:       []string{turnServer},
154 | 		Username:   username,
155 | 		Credential: base64.StdEncoding.EncodeToString(mac.Sum(nil)),
156 | 	}}
157 | }
158 | 
159 | // relay sets up a rendezvous on a slot and pipes the two websockets together.
160 | func relay(w http.ResponseWriter, r *http.Request) {
161 | 	slotkey := r.URL.Path[1:] // strip leading slash
162 | 	var rconn *websocket.Conn
163 | 	conn, err := websocket.Accept(w, r, &websocket.AcceptOptions{
164 | 		// This sounds nasty but checking origin only matters if requests
165 | 		// change any user state on the server, aka CSRF. We don't have any
166 | 		// user state other than this ephemeral connection. So it's fine.
167 | 		InsecureSkipVerify: true,
168 | 
169 | 		// Safari has broken compression.
170 | 		// https://github.com/nhooyr/websocket/issues/218
171 | 		CompressionMode: websocket.CompressionDisabled,
172 | 
173 | 		// Protocol version negotiation.
174 | 		Subprotocols: []string{wormhole.Protocol},
175 | 	})
176 | 	if err != nil {
177 | 		log.Println(err)
178 | 		return
179 | 	}
180 | 	if conn.Subprotocol() != wormhole.Protocol {
181 | 		// Make sure we negotiated the right protocol, since "blank" is also a
182 | 		// default one.
183 | 		protocolErrorCounter.WithLabelValues("wrongversion").Inc()
184 | 		conn.Close(wormhole.CloseWrongProto, "wrong protocol, please upgrade client")
185 | 		return
186 | 	}
187 | 
188 | 	ctx, cancel := context.WithTimeout(r.Context(), slotTimeout)
189 | 
190 | 	initmsg := struct {
191 | 		Slot       string             `json:"slot",omitempty`
192 | 		ICEServers []webrtc.ICEServer `json:"iceServers",omitempty`
193 | 	}{}
194 | 	initmsg.ICEServers = append(turnServers(), stunServers...)
195 | 
196 | 	go func() {
197 | 		if slotkey == "" {
198 | 			// Book a new slot.
199 | 			slots.Lock()
200 | 			newslot, ok := freeslot()
201 | 			if !ok {
202 | 				slots.Unlock()
203 | 				rendezvousCounter.WithLabelValues("nomoreslots").Inc()
204 | 				conn.Close(wormhole.CloseNoMoreSlots, "cannot allocate slots")
205 | 				return
206 | 			}
207 | 			slotkey = newslot
208 | 			sc := make(chan *websocket.Conn)
209 | 			slots.m[slotkey] = sc
210 | 			slotsGuage.Set(float64(len(slots.m)))
211 | 			slots.Unlock()
212 | 			initmsg.Slot = slotkey
213 | 			buf, err := json.Marshal(initmsg)
214 | 			if err != nil {
215 | 				log.Println(err)
216 | 				slots.Lock()
217 | 				delete(slots.m, slotkey)
218 | 				slotsGuage.Set(float64(len(slots.m)))
219 | 				slots.Unlock()
220 | 				return
221 | 			}
222 | 			err = conn.Write(ctx, websocket.MessageText, buf)
223 | 			if err != nil {
224 | 				log.Println(err)
225 | 				slots.Lock()
226 | 				delete(slots.m, slotkey)
227 | 				slotsGuage.Set(float64(len(slots.m)))
228 | 				slots.Unlock()
229 | 				return
230 | 			}
231 | 
232 | 		wait:
233 | 			for {
234 | 				select {
235 | 				case <-ctx.Done():
236 | 					rendezvousCounter.WithLabelValues("timeout").Inc()
237 | 					slots.Lock()
238 | 					delete(slots.m, slotkey)
239 | 					slotsGuage.Set(float64(len(slots.m)))
240 | 					slots.Unlock()
241 | 					conn.Close(wormhole.CloseSlotTimedOut, "timed out")
242 | 					return
243 | 				case <-time.After(30 * time.Second):
244 | 					// Do a WebSocket Ping every 30 seconds.
245 | 					conn.Ping(ctx)
246 | 				case sc <- conn:
247 | 					break wait
248 | 				}
249 | 			}
250 | 			rconn = <-sc
251 | 			rendezvousCounter.WithLabelValues("success").Inc()
252 | 			return
253 | 		}
254 | 
255 | 		// Join an existing slot.
256 | 		slots.Lock()
257 | 		sc, ok := slots.m[slotkey]
258 | 		if !ok {
259 | 			slots.Unlock()
260 | 			rendezvousCounter.WithLabelValues("nosuchslot").Inc()
261 | 			conn.Close(wormhole.CloseNoSuchSlot, "no such slot")
262 | 			return
263 | 		}
264 | 		delete(slots.m, slotkey)
265 | 		slotsGuage.Set(float64(len(slots.m)))
266 | 		slots.Unlock()
267 | 		initmsg.Slot = slotkey
268 | 		buf, err := json.Marshal(initmsg)
269 | 		if err != nil {
270 | 			log.Println(err)
271 | 			return
272 | 		}
273 | 		err = conn.Write(ctx, websocket.MessageText, buf)
274 | 		if err != nil {
275 | 			log.Println(err)
276 | 			return
277 | 		}
278 | 		select {
279 | 		case <-ctx.Done():
280 | 			conn.Close(wormhole.CloseSlotTimedOut, "timed out")
281 | 		case rconn = <-sc:
282 | 		}
283 | 		sc <- conn
284 | 		rendezvousCounter.WithLabelValues("success").Inc()
285 | 	}()
286 | 
287 | 	defer cancel()
288 | 	for {
289 | 		msgType, p, err := conn.Read(ctx)
290 | 		switch websocket.CloseStatus(err) {
291 | 		case wormhole.CloseBadKey:
292 | 			iceCounter.WithLabelValues("fail", "badkey").Inc()
293 | 			if rconn != nil {
294 | 				rconn.Close(wormhole.CloseBadKey, "bad key")
295 | 			}
296 | 			return
297 | 		case wormhole.CloseWebRTCFailed:
298 | 			iceCounter.WithLabelValues("fail", "unknown").Inc()
299 | 			return
300 | 		case wormhole.CloseWebRTCSuccess:
301 | 			iceCounter.WithLabelValues("success", "unknown").Inc()
302 | 			return
303 | 		case wormhole.CloseWebRTCSuccessDirect:
304 | 			iceCounter.WithLabelValues("success", "direct").Inc()
305 | 			return
306 | 		case wormhole.CloseWebRTCSuccessRelay:
307 | 			iceCounter.WithLabelValues("success", "relay").Inc()
308 | 			return
309 | 		}
310 | 		if err != nil {
311 | 			iceCounter.WithLabelValues("unknown", "unknown").Inc()
312 | 			if rconn != nil {
313 | 				rconn.Close(wormhole.ClosePeerHungUp, "peer hung up")
314 | 			}
315 | 			return
316 | 		}
317 | 		if rconn == nil {
318 | 			// We could synchronise with the rendezvous goroutine above and wait for
319 | 			// B to connect, but receiving anything at this stage is a protocol violation
320 | 			// so we should just bail out.
321 | 			return
322 | 		}
323 | 		err = rconn.Write(ctx, msgType, p)
324 | 		if err != nil {
325 | 			return
326 | 		}
327 | 	}
328 | }
329 | 
330 | func server(args ...string) {
331 | 	rand.Seed(time.Now().UnixNano()) // for slot allocation
332 | 
333 | 	set := flag.NewFlagSet(args[0], flag.ExitOnError)
334 | 	set.Usage = func() {
335 | 		fmt.Fprintf(set.Output(), "run the webwormhole signalling server\n\n")
336 | 		fmt.Fprintf(set.Output(), "usage: %s %s\n\n", os.Args[0], args[0])
337 | 		fmt.Fprintf(set.Output(), "flags:\n")
338 | 		set.PrintDefaults()
339 | 	}
340 | 	httpaddr := set.String("http", ":http", "http listen address")
341 | 	httpsaddr := set.String("https", ":https", "https listen address")
342 | 	debugaddr := set.String("debug", "", "debug and metrics listen address")
343 | 	hosts := set.String("hosts", "", "comma separated list of hosts by which site is accessible")
344 | 	secretpath := set.String("secrets", os.Getenv("HOME")+"/keys", "path to put let's encrypt cache")
345 | 	cert := set.String("cert", "", "https certificate (leave empty to use letsencrypt)")
346 | 	key := set.String("key", "", "https certificate key")
347 | 	html := set.String("ui", "./web", "path to the web interface files")
348 | 	stunservers := set.String("stun", "stun:relay.webwormhole.io", "list of STUN server addresses to tell clients to use")
349 | 	set.StringVar(&turnServer, "turn", "", "TURN server to use for relaying")
350 | 	set.StringVar(&turnSecret, "turn-secret", "", "secret for HMAC-based authentication in TURN server")
351 | 	set.Parse(args[1:])
352 | 
353 | 	if (*cert == "") != (*key == "") {
354 | 		log.Fatalf("-cert and -key options must be provided together or both left empty")
355 | 	}
356 | 
357 | 	if turnServer != "" && turnSecret == "" {
358 | 		log.Fatal("cannot use a TURN server without a secret")
359 | 	}
360 | 
361 | 	for _, s := range strings.Split(*stunservers, ",") {
362 | 		if s == "" {
363 | 			continue
364 | 		}
365 | 		stunServers = append(stunServers, webrtc.ICEServer{URLs: []string{s}})
366 | 	}
367 | 
368 | 	fs := gziphandler.GzipHandler(http.FileServer(http.Dir(*html)))
369 | 	handler := func(w http.ResponseWriter, r *http.Request) {
370 | 		// Handle WebSocket connections.
371 | 		if strings.ToLower(r.Header.Get("Upgrade")) == "websocket" {
372 | 			relay(w, r)
373 | 			return
374 | 		}
375 | 
376 | 		// Allow 3rd parties to load JS modules, etc.
377 | 		w.Header().Set("Access-Control-Allow-Origin", "*")
378 | 
379 | 		// Disallow 3rd party code to run when we're the origin.
380 | 		// unsafe-eval is required for wasm :(
381 | 		// https://github.com/WebAssembly/content-security-policy/issues/7
382 | 		// connect-src is required for safari :(
383 | 		// https://bugs.webkit.org/show_bug.cgi?id=201591
384 | 		csp := "default-src 'self'; script-src 'self' 'unsafe-eval'; img-src 'self' blob:; connect-src 'self' ws://localhost/"
385 | 		for _, host := range strings.Split(*hosts, ",") {
386 | 			csp += fmt.Sprintf(" wss://%v", host)
387 | 		}
388 | 		w.Header().Set("Content-Security-Policy", csp)
389 | 
390 | 		// Set a small max age for cache. We might want to switch to a content-addressed
391 | 		// resource naming scheme and change this to immutable, but until then disable caching.
392 | 		w.Header().Set("Cache-Control", "no-cache")
393 | 
394 | 		// Set HSTS header for 2 years on HTTPS connections.
395 | 		if *httpsaddr != "" {
396 | 			w.Header().Set("Strict-Transport-Security", "max-age=63072000")
397 | 		}
398 | 
399 | 		// Return a redirect to source code repo for the go get URL.
400 | 		if r.URL.Query().Get("go-get") == "1" || r.URL.Path == "/cmd/ww" {
401 | 			w.Write([]byte(importMeta))
402 | 			return
403 | 		}
404 | 
405 | 		// Handle the Service Worker private prefix. A well-behaved Service Worker
406 | 		// must *never* reach us on this path.
407 | 		if strings.HasPrefix(r.URL.Path, "/_/") {
408 | 			protocolErrorCounter.WithLabelValues("serviceworkererr").Inc()
409 | 			http.Error(w, serviceWorkerPage, http.StatusNotFound)
410 | 			return
411 | 		}
412 | 
413 | 		fs.ServeHTTP(w, r)
414 | 	}
415 | 
416 | 	m := &autocert.Manager{
417 | 		Cache:      autocert.DirCache(*secretpath),
418 | 		Prompt:     autocert.AcceptTOS,
419 | 		HostPolicy: autocert.HostWhitelist(strings.Split(*hosts, ",")...),
420 | 	}
421 | 
422 | 	ssrv := &http.Server{
423 | 		ReadTimeout:  10 * time.Second,
424 | 		WriteTimeout: 60 * time.Minute,
425 | 		IdleTimeout:  20 * time.Second,
426 | 		Addr:         *httpsaddr,
427 | 		Handler:      http.HandlerFunc(handler),
428 | 		TLSConfig: &tls.Config{
429 | 			MinVersion: tls.VersionTLS12,
430 | 			CipherSuites: []uint16{
431 | 				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
432 | 				tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
433 | 				tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
434 | 				tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
435 | 				tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
436 | 				tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
437 | 			},
438 | 		},
439 | 	}
440 | 	srv := &http.Server{
441 | 		ReadTimeout:  10 * time.Second,
442 | 		WriteTimeout: 60 * time.Minute,
443 | 		IdleTimeout:  20 * time.Second,
444 | 		Addr:         *httpaddr,
445 | 		Handler:      m.HTTPHandler(http.HandlerFunc(handler)),
446 | 	}
447 | 
448 | 	if *cert == "" && *key == "" {
449 | 		ssrv.TLSConfig.GetCertificate = m.GetCertificate
450 | 	}
451 | 
452 | 	errc := make(chan error)
453 | 	if *debugaddr != "" {
454 | 		http.Handle("/metrics", promhttp.Handler())
455 | 		go func() { errc <- http.ListenAndServe(*debugaddr, nil) }()
456 | 	}
457 | 	if *httpsaddr != "" {
458 | 		srv.Handler = m.HTTPHandler(nil) // Enable redirect to https handler.
459 | 		go func() { errc <- ssrv.ListenAndServeTLS(*cert, *key) }()
460 | 	}
461 | 	if *httpaddr != "" {
462 | 		go func() { errc <- srv.ListenAndServe() }()
463 | 	}
464 | 	log.Fatal(<-errc)
465 | }
466 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module webwormhole.io
 2 | 
 3 | go 1.24.3
 4 | 
 5 | require (
 6 | 	filippo.io/cpace v0.0.0-20210101143347-24d601e2e469
 7 | 	github.com/NYTimes/gziphandler v1.1.1
 8 | 	github.com/pion/webrtc/v3 v3.3.5
 9 | 	github.com/prometheus/client_golang v1.22.0
10 | 	golang.org/x/crypto v0.38.0
11 | 	golang.org/x/net v0.40.0
12 | 	nhooyr.io/websocket v1.8.17
13 | 	rsc.io/qr v0.2.0
14 | )
15 | 
16 | require (
17 | 	github.com/beorn7/perks v1.0.1 // indirect
18 | 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
19 | 	github.com/davecgh/go-spew v1.1.1 // indirect
20 | 	github.com/golang/protobuf v1.5.4 // indirect
21 | 	github.com/google/uuid v1.6.0 // indirect
22 | 	github.com/gtank/ristretto255 v0.1.2 // indirect
23 | 	github.com/json-iterator/go v1.1.12 // indirect
24 | 	github.com/klauspost/compress v1.18.0 // indirect
25 | 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
26 | 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
27 | 	github.com/modern-go/reflect2 v1.0.2 // indirect
28 | 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
29 | 	github.com/pion/datachannel v1.5.10 // indirect
30 | 	github.com/pion/dtls/v2 v2.2.12 // indirect
31 | 	github.com/pion/ice/v2 v2.3.37 // indirect
32 | 	github.com/pion/interceptor v0.1.37 // indirect
33 | 	github.com/pion/logging v0.2.3 // indirect
34 | 	github.com/pion/mdns v0.0.12 // indirect
35 | 	github.com/pion/randutil v0.1.0 // indirect
36 | 	github.com/pion/rtcp v1.2.15 // indirect
37 | 	github.com/pion/rtp v1.8.15 // indirect
38 | 	github.com/pion/sctp v1.8.39 // indirect
39 | 	github.com/pion/sdp/v3 v3.0.11 // indirect
40 | 	github.com/pion/srtp/v2 v2.0.20 // indirect
41 | 	github.com/pion/stun v0.6.1 // indirect
42 | 	github.com/pion/transport/v2 v2.2.10 // indirect
43 | 	github.com/pion/transport/v3 v3.0.7 // indirect
44 | 	github.com/pion/turn/v2 v2.1.6 // indirect
45 | 	github.com/pion/udp/v2 v2.0.1 // indirect
46 | 	github.com/pmezard/go-difflib v1.0.0 // indirect
47 | 	github.com/prometheus/client_model v0.6.2 // indirect
48 | 	github.com/prometheus/common v0.64.0 // indirect
49 | 	github.com/prometheus/procfs v0.16.1 // indirect
50 | 	github.com/stretchr/testify v1.10.0 // indirect
51 | 	github.com/wlynxg/anet v0.0.5 // indirect
52 | 	golang.org/x/sys v0.33.0 // indirect
53 | 	golang.org/x/text v0.25.0 // indirect
54 | 	google.golang.org/protobuf v1.36.6 // indirect
55 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
56 | )
57 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
  1 | filippo.io/cpace v0.0.0-20210101143347-24d601e2e469 h1:+gAICE3DIgwMKUzUuVCjd5R4ws+HFL19bKegPYkcgmQ=
  2 | filippo.io/cpace v0.0.0-20210101143347-24d601e2e469/go.mod h1:b8UFwXF0HGYD8OWBGJEPwu3IMDHqTpzCtGFtY2xRwTU=
  3 | github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cqUQ3I=
  4 | github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c=
  5 | github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
  6 | github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
  7 | github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
  8 | github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
  9 | github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 10 | github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 11 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 12 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 13 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 14 | github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 15 | github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 16 | github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 17 | github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 18 | github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
 19 | github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
 20 | github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 21 | github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 22 | github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 23 | github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
 24 | github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 25 | github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
 26 | github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 27 | github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 28 | github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
 29 | github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
 30 | github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
 31 | github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 32 | github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
 33 | github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 34 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 35 | github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 36 | github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
 37 | github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 38 | github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 39 | github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
 40 | github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 41 | github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 42 | github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 43 | github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 44 | github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 45 | github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 46 | github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 47 | github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 48 | github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 49 | github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 50 | github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 51 | github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 52 | github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 53 | github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 54 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 55 | github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 56 | github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 57 | github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 58 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 59 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 60 | github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 61 | github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 62 | github.com/gtank/ristretto255 v0.1.2 h1:JEqUCPA1NvLq5DwYtuzigd7ss8fwbYay9fi4/5uMzcc=
 63 | github.com/gtank/ristretto255 v0.1.2/go.mod h1:Ph5OpO6c7xKUGROZfWVLiJf9icMDwUeIvY4OmlYW69o=
 64 | github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 65 | github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 66 | github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 67 | github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 68 | github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 69 | github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw=
 70 | github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4=
 71 | github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 72 | github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 73 | github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 74 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 75 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 76 | github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 77 | github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 78 | github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 79 | github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 80 | github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 81 | github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
 82 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 83 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 84 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 85 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 86 | github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 87 | github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 88 | github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 89 | github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 90 | github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 91 | github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 92 | github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 93 | github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 94 | github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
 95 | github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 96 | github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 97 | github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 98 | github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 99 | github.com/pion/datachannel v1.5.5 h1:10ef4kwdjije+M9d7Xm9im2Y3O6A6ccQb0zcqZcJew8=
100 | github.com/pion/datachannel v1.5.5/go.mod h1:iMz+lECmfdCMqFRhXhcA/219B0SQlbpoR2V118yimL0=
101 | github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
102 | github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
103 | github.com/pion/dtls/v2 v2.2.6 h1:yXMxKr0Skd+Ub6A8UqXTRLSywskx93ooMRHsQUtd+Z4=
104 | github.com/pion/dtls/v2 v2.2.6/go.mod h1:t8fWJCIquY5rlQZwA2yWxUS1+OCrAdXrhVKXB5oD/wY=
105 | github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
106 | github.com/pion/dtls/v2 v2.2.12 h1:KP7H5/c1EiVAAKUmXyCzPiQe5+bCJrpOeKg/L05dunk=
107 | github.com/pion/dtls/v2 v2.2.12/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE=
108 | github.com/pion/ice/v2 v2.3.1 h1:FQCmUfZe2Jpe7LYStVBOP6z1DiSzbIateih3TztgTjc=
109 | github.com/pion/ice/v2 v2.3.1/go.mod h1:aq2kc6MtYNcn4XmMhobAv6hTNJiHzvD0yXRz80+bnP8=
110 | github.com/pion/ice/v2 v2.3.37 h1:ObIdaNDu1rCo7hObhs34YSBcO7fjslJMZV0ux+uZWh0=
111 | github.com/pion/ice/v2 v2.3.37/go.mod h1:mBF7lnigdqgtB+YHkaY/Y6s6tsyRyo4u4rPGRuOjUBQ=
112 | github.com/pion/interceptor v0.1.12 h1:CslaNriCFUItiXS5o+hh5lpL0t0ytQkFnUcbbCs2Zq8=
113 | github.com/pion/interceptor v0.1.12/go.mod h1:bDtgAD9dRkBZpWHGKaoKb42FhDHTG2rX8Ii9LRALLVA=
114 | github.com/pion/interceptor v0.1.37 h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=
115 | github.com/pion/interceptor v0.1.37/go.mod h1:JzxbJ4umVTlZAf+/utHzNesY8tmRkM2lVmkS82TTj8Y=
116 | github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
117 | github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
118 | github.com/pion/logging v0.2.3 h1:gHuf0zpoh1GW67Nr6Gj4cv5Z9ZscU7g/EaoC/Ke/igI=
119 | github.com/pion/logging v0.2.3/go.mod h1:z8YfknkquMe1csOrxK5kc+5/ZPAzMxbKLX5aXpbpC90=
120 | github.com/pion/mdns v0.0.7 h1:P0UB4Sr6xDWEox0kTVxF0LmQihtCbSAdW0H2nEgkA3U=
121 | github.com/pion/mdns v0.0.7/go.mod h1:4iP2UbeFhLI/vWju/bw6ZfwjJzk0z8DNValjGxR/dD8=
122 | github.com/pion/mdns v0.0.12 h1:CiMYlY+O0azojWDmxdNr7ADGrnZ+V6Ilfner+6mSVK8=
123 | github.com/pion/mdns v0.0.12/go.mod h1:VExJjv8to/6Wqm1FXK+Ii/Z9tsVk/F5sD/N70cnYFbk=
124 | github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
125 | github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
126 | github.com/pion/rtcp v1.2.10 h1:nkr3uj+8Sp97zyItdN60tE/S6vk4al5CPRR6Gejsdjc=
127 | github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I=
128 | github.com/pion/rtcp v1.2.12/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4=
129 | github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
130 | github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
131 | github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
132 | github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
133 | github.com/pion/rtp v1.8.3/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
134 | github.com/pion/rtp v1.8.15 h1:MuhuGn1cxpVCPLNY1lI7F1tQ8Spntpgf12ob+pOYT8s=
135 | github.com/pion/rtp v1.8.15/go.mod h1:bAu2UFKScgzyFqvUKmbvzSdPr+NGbZtv6UB2hesqXBk=
136 | github.com/pion/sctp v1.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
137 | github.com/pion/sctp v1.8.6 h1:CUex11Vkt9YS++VhLf8b55O3VqKrWL6W3SDwX4jAqsI=
138 | github.com/pion/sctp v1.8.6/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
139 | github.com/pion/sctp v1.8.39 h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=
140 | github.com/pion/sctp v1.8.39/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
141 | github.com/pion/sdp/v3 v3.0.6 h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw=
142 | github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
143 | github.com/pion/sdp/v3 v3.0.11 h1:VhgVSopdsBKwhCFoyyPmT1fKMeV9nLMrEKxNOdy3IVI=
144 | github.com/pion/sdp/v3 v3.0.11/go.mod h1:88GMahN5xnScv1hIMTqLdu/cOcUkj6a9ytbncwMCq2E=
145 | github.com/pion/srtp/v2 v2.0.12 h1:WrmiVCubGMOAObBU1vwWjG0H3VSyQHawKeer2PVA5rY=
146 | github.com/pion/srtp/v2 v2.0.12/go.mod h1:C3Ep44hlOo2qEYaq4ddsmK5dL63eLehXFbHaZ9F5V9Y=
147 | github.com/pion/srtp/v2 v2.0.20 h1:HNNny4s+OUmG280ETrCdgFndp4ufx3/uy85EawYEhTk=
148 | github.com/pion/srtp/v2 v2.0.20/go.mod h1:0KJQjA99A6/a0DOVTu1PhDSw0CXF2jTkqOoMg3ODqdA=
149 | github.com/pion/stun v0.4.0 h1:vgRrbBE2htWHy7l3Zsxckk7rkjnjOsSM7PHZnBwo8rk=
150 | github.com/pion/stun v0.4.0/go.mod h1:QPsh1/SbXASntw3zkkrIk3ZJVKz4saBY2G7S10P3wCw=
151 | github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
152 | github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
153 | github.com/pion/transport v0.14.1 h1:XSM6olwW+o8J4SCmOBb/BpwZypkHeyM0PGFCxNQBr40=
154 | github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99Jn2fNnI=
155 | github.com/pion/transport/v2 v2.0.0/go.mod h1:HS2MEBJTwD+1ZI2eSXSvHJx/HnzQqRy2/LXxt6eVMHc=
156 | github.com/pion/transport/v2 v2.0.2 h1:St+8o+1PEzPT51O9bv+tH/KYYLMNR5Vwm5Z3Qkjsywg=
157 | github.com/pion/transport/v2 v2.0.2/go.mod h1:vrz6bUbFr/cjdwbnxq8OdDDzHf7JJfGsIRkxfpZoTA0=
158 | github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
159 | github.com/pion/transport/v2 v2.2.3/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
160 | github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
161 | github.com/pion/transport/v2 v2.2.10 h1:ucLBLE8nuxiHfvkFKnkDQRYWYfp8ejf4YBOPfaQpw6Q=
162 | github.com/pion/transport/v2 v2.2.10/go.mod h1:sq1kSLWs+cHW9E+2fJP95QudkzbK7wscs8yYgQToO5E=
163 | github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0=
164 | github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
165 | github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
166 | github.com/pion/turn/v2 v2.1.0 h1:5wGHSgGhJhP/RpabkUb/T9PdsAjkGLS6toYz5HNzoSI=
167 | github.com/pion/turn/v2 v2.1.0/go.mod h1:yrT5XbXSGX1VFSF31A3c1kCNB5bBZgk/uu5LET162qs=
168 | github.com/pion/turn/v2 v2.1.3/go.mod h1:huEpByKKHix2/b9kmTAM3YoX6MKP+/D//0ClgUYR2fY=
169 | github.com/pion/turn/v2 v2.1.6 h1:Xr2niVsiPTB0FPtt+yAWKFUkU1eotQbGgpTIld4x1Gc=
170 | github.com/pion/turn/v2 v2.1.6/go.mod h1:huEpByKKHix2/b9kmTAM3YoX6MKP+/D//0ClgUYR2fY=
171 | github.com/pion/udp/v2 v2.0.1 h1:xP0z6WNux1zWEjhC7onRA3EwwSliXqu1ElUZAQhUP54=
172 | github.com/pion/udp/v2 v2.0.1/go.mod h1:B7uvTMP00lzWdyMr/1PVZXtV3wpPIxBRd4Wl6AksXn8=
173 | github.com/pion/webrtc/v3 v3.1.56 h1:ScaiqKQN3liQwT+kJwOBaYP6TwSfixzdUnZmzHAo0a0=
174 | github.com/pion/webrtc/v3 v3.1.56/go.mod h1:7VhbA6ihqJlz6R/INHjyh1b8HpiV9Ct4UQvE1OB/xoM=
175 | github.com/pion/webrtc/v3 v3.3.5 h1:ZsSzaMz/i9nblPdiAkZoP+E6Kmjw+jnyq3bEmU3EtRg=
176 | github.com/pion/webrtc/v3 v3.3.5/go.mod h1:liNa+E1iwyzyXqNUwvoMRNQ10x8h8FOeJKL8RkIbamE=
177 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
178 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
179 | github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
180 | github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
181 | github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
182 | github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
183 | github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4=
184 | github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w=
185 | github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
186 | github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
187 | github.com/prometheus/common v0.40.0 h1:Afz7EVRqGg2Mqqf4JuF9vdvp1pi220m55Pi9T2JnO4Q=
188 | github.com/prometheus/common v0.40.0/go.mod h1:L65ZJPSmfn/UBWLQIHV7dBrKFidB/wPlF1y5TlSt9OE=
189 | github.com/prometheus/common v0.64.0 h1:pdZeA+g617P7oGv1CzdTzyeShxAGrTBsolKNOLQPGO4=
190 | github.com/prometheus/common v0.64.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
191 | github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI=
192 | github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY=
193 | github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
194 | github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
195 | github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
196 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
197 | github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
198 | github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
199 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
200 | github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
201 | github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
202 | github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
203 | github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
204 | github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
205 | github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
206 | github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
207 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
208 | github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
209 | github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
210 | github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
211 | github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
212 | github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
213 | github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
214 | github.com/wlynxg/anet v0.0.3/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
215 | github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
216 | github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
217 | github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
218 | github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
219 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
220 | golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
221 | golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
222 | golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
223 | golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
224 | golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
225 | golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
226 | golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
227 | golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
228 | golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
229 | golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
230 | golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
231 | golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
232 | golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
233 | golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
234 | golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
235 | golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
236 | golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
237 | golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
238 | golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
239 | golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
240 | golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
241 | golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
242 | golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
243 | golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
244 | golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
245 | golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
246 | golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
247 | golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
248 | golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
249 | golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
250 | golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
251 | golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
252 | golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
253 | golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
254 | golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
255 | golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
256 | golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
257 | golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
258 | golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
259 | golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
260 | golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
261 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
262 | golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
263 | golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
264 | golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
265 | golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
266 | golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
267 | golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
268 | golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
269 | golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
270 | golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
271 | golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
272 | golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
273 | golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
274 | golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
275 | golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
276 | golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
277 | golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
278 | golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
279 | golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
280 | golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
281 | golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
282 | golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
283 | golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
284 | golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
285 | golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
286 | golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
287 | golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
288 | golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
289 | golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
290 | golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
291 | golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
292 | golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
293 | golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
294 | golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
295 | golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
296 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
297 | golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
298 | golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
299 | golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
300 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
301 | golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
302 | golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
303 | golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
304 | golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
305 | golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
306 | golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
307 | golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
308 | golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
309 | golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
310 | golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
311 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
312 | golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
313 | golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
314 | golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
315 | golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
316 | golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
317 | golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
318 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
319 | golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
320 | google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
321 | google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
322 | google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
323 | google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
324 | google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
325 | google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
326 | google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
327 | google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
328 | google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
329 | google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
330 | google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
331 | google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
332 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
333 | gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
334 | gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
335 | gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
336 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
337 | gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
338 | gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
339 | gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
340 | gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
341 | gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
342 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
343 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
344 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
345 | nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g=
346 | nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=
347 | nhooyr.io/websocket v1.8.17 h1:KEVeLJkUywCKVsnLIDlD/5gtayKp8VoCkksHCGGfT9Y=
348 | nhooyr.io/websocket v1.8.17/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c=
349 | rsc.io/qr v0.2.0 h1:6vBLea5/NRMVTz8V66gipeLycZMl/+UlFmk8DvqQ6WY=
350 | rsc.io/qr v0.2.0/go.mod h1:IF+uZjkb9fqyeF/4tlBoynqmQxUoPfWEKh921coOuXs=
351 | 


--------------------------------------------------------------------------------
/web/icon.svg:
--------------------------------------------------------------------------------
 1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 512 512" height="512" width="512">
 2 | <defs>
 3 | <polygon
 4 | points="265, 0, 486.7, 128, 486.7, 384, 265, 512, 34.3, 384, 34.3, 128"
 5 | stroke-width="5" stroke="#FF7000"
 6 | id="h"
 7 | />
 8 | </defs>
 9 | <!--<rect x="6" y="6" width="500" height="500" rx="64" />-->
10 | <use xlink:href="#h" fill="#910074" transform="translate(256,256) scale(0.85, 0.85) translate(-256,-256) rotate(30,256,256)" style="filter: drop-shadow(rgba(255, 255, 255, 0.6) 0px 0px 20px);" />
11 | <use xlink:href="#h" fill="#570045" transform="translate(256,256) scale(0.60, 0.60) translate(-256,-256) rotate(50,256,256)" />
12 | <use xlink:href="#h" fill="#310027" transform="translate(256,256) scale(0.35, 0.35) translate(-256,-256) rotate(70,256,256)" />
13 | </svg>
14 | 


--------------------------------------------------------------------------------
/web/icon128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon128.png


--------------------------------------------------------------------------------
/web/icon16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon16.png


--------------------------------------------------------------------------------
/web/icon192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon192.png


--------------------------------------------------------------------------------
/web/icon48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon48.png


--------------------------------------------------------------------------------
/web/icon512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon512.png


--------------------------------------------------------------------------------
/web/icon96.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saljam/webwormhole/386ff1be3993df03470ebc5a982b79f41c6429c6/web/icon96.png


--------------------------------------------------------------------------------
/web/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <meta charset="utf-8" />
 4 | <meta name="description" content="Send files from one place to another." />
 5 | <meta name="go-import" content="webwormhole.io git https://github.com/saljam/webwormhole" />
 6 | <meta name="viewport" content="width=device-width, height=device-height" />
 7 | <meta name="apple-mobile-web-app-capable" content="yes">
 8 | <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
 9 | <link rel="icon" href="icon192.png" />
10 | <link rel="apple-touch-icon" href="icon192.png">
11 | <link rel="manifest" href="/pwa.json">
12 | <link rel="stylesheet" href="style.css" />
13 | <script src="wasm_exec.js"></script>
14 | <script src="ww.js"></script>
15 | <script src="main.js"></script>
16 | <title>WebWormhole</title>
17 | <body>
18 | <form id="main" role="main">
19 | <p id="info">WebWormhole lets you send files from one computer to another.</p>
20 | <div id="top">
21 | Drag and drop, <label id="filepicker-wrap" class="button">OPEN<input type="file" id="filepicker" disabled /></label>, or <input type="button" id="clipboard" class="button" value="PASTE" disabled /> files and text to send.
22 | </div>
23 | <ul id="transfers"></ul>
24 | <div id="prompt">
25 | <p>Type a wormhole's phrase to join it, or leave empty to create a new one.</p>
26 | <img id="qr" />
27 | <input type="text" id="magiccode" autocomplete="off" autofocus title="wormhole phrase" placeholder="wormhole phrase" />
28 | <input type="submit" id="dial" class="button" value="LOADING..." disabled />
29 | <span id="autocomplete"></span>
30 | </div>
31 | <div id="footer">
32 | <ul>
33 | <li>source: <a href="https://github.com/saljam/webwormhole">github.com/saljam/webwormhole</a></li>
34 | <li>feedback: <a href="mailto:s@lj.am">s@lj.am</a> <a href="https://twitter.com/_saljam">@_saljam</a></li>
35 | <li>install: <a href="https://addons.mozilla.org/firefox/addon/webwormhole/">firefox</a> <a href="https://chrome.google.com/webstore/detail/webwormhole/jhombkhjanncdalcbcahinpjoacaiidn">chrome</a> <a href="https://pkg.go.dev/webwormhole.io/cmd/ww">command line</a></li>
36 | </ul>
37 | </div>
38 | </form>
39 | </body>
40 | </html>
41 | 


--------------------------------------------------------------------------------
/web/main.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | /// <reference path="ww.ts" />
  3 | // Flags corresponding to browser specific quirks.
  4 | const hacks = {};
  5 | // receiving is the object currently being received.
  6 | let receiving;
  7 | // sending is the object currently being sent.
  8 | let sending;
  9 | // sendqueue is the queue of objects waiting to be sent.
 10 | let sendqueue = [];
 11 | // state is the top-level connection state.
 12 | let state = "disconnected";
 13 | // datachannel is the active datachannel, if we're connected.
 14 | let datachannel;
 15 | // serviceworker is the helper download service worker, if enabled.
 16 | let serviceworker;
 17 | // signalserver is the address of the signalling server.
 18 | let signalserver = new URL(location.href);
 19 | // peerconnection is the active connection's WebRTC object. Global to help debugging.
 20 | let peerconnection;
 21 | // UI elements.
 22 | let filepicker;
 23 | let dialButton;
 24 | let phraseInput;
 25 | let clipboardInput;
 26 | let mainForm;
 27 | let qrImg;
 28 | let transfersList;
 29 | let infoBox;
 30 | let autocompleteBox;
 31 | class DataChannelWriter {
 32 |     constructor(dc) {
 33 |         this.chunksize = 32 << 10;
 34 |         this.bufferedAmountHighThreshold = 1 << 20;
 35 |         this.bufferedAmountLowThreshold = 1 << 20;
 36 |         this.dc = dc;
 37 |         this.dc.bufferedAmountLowThreshold = this.bufferedAmountLowThreshold;
 38 |         this.dc.onbufferedamountlow = () => {
 39 |             if (this.resolve)
 40 |                 this.resolve();
 41 |         };
 42 |         this.ready = new Promise((resolve) => {
 43 |             this.resolve = resolve; // TODO needed?
 44 |             this.resolve();
 45 |         });
 46 |     }
 47 |     async write(buf) {
 48 |         for (let offset = 0; offset < buf.length; offset += this.chunksize) {
 49 |             let end = offset + this.chunksize;
 50 |             if (end > buf.length) {
 51 |                 end = buf.length;
 52 |             }
 53 |             await this.ready;
 54 |             this.dc.send(buf.subarray(offset, end));
 55 |         }
 56 |         if (this.dc.bufferedAmount >= this.bufferedAmountHighThreshold) {
 57 |             this.ready = new Promise((resolve) => {
 58 |                 this.resolve = resolve;
 59 |             });
 60 |         }
 61 |     }
 62 | }
 63 | class Upload {
 64 |     constructor(header, data) {
 65 |         this.offset = 0;
 66 |         this.li = document.createElement("li");
 67 |         this.progress = document.createElement("progress");
 68 |         this.header = header;
 69 |         if (data instanceof ReadableStream) {
 70 |             this.stream = data;
 71 |         }
 72 |         else {
 73 |             this.blob = data;
 74 |             if (data.stream) {
 75 |                 this.stream = data.stream();
 76 |             }
 77 |         }
 78 |     }
 79 |     async send(dc) {
 80 |         console.log("sending", this.header.name, this.header.type);
 81 |         this.li.classList.remove("pending");
 82 |         this.li.classList.add("upload");
 83 |         this.li.appendChild(document.createElement("progress"));
 84 |         this.progress = this.li.getElementsByTagName("progress")[0];
 85 |         dc.send(new TextEncoder().encode(JSON.stringify(this.header)));
 86 |         const writer = new DataChannelWriter(dc);
 87 |         if (this.stream) {
 88 |             const reader = this.stream.getReader();
 89 |             while (true) {
 90 |                 const { done, value } = await reader.read();
 91 |                 if (done) {
 92 |                     break;
 93 |                 }
 94 |                 await writer.write(value);
 95 |                 this.offset += value.length;
 96 |                 this.progress.value = this.offset / this.header.size;
 97 |             }
 98 |             this.li.removeChild(this.progress);
 99 |             return;
100 |         }
101 |         if (this.blob) {
102 |             // Backwards compatability with browsers that don't have Blob.stream. (Safari pre-14.1)
103 |             let read = (b) => {
104 |                 return new Promise((resolve) => {
105 |                     const fr = new FileReader();
106 |                     fr.onload = () => {
107 |                         resolve(new Uint8Array(fr.result));
108 |                     };
109 |                     fr.readAsArrayBuffer(b);
110 |                 });
111 |             };
112 |             const chunksize = 64 << 10;
113 |             while (this.offset < this.header.size) {
114 |                 let end = this.offset + chunksize;
115 |                 if (end > this.blob.size) {
116 |                     end = this.blob.size;
117 |                 }
118 |                 await writer.write(await read(this.blob.slice(this.offset, end)));
119 |                 this.offset = end;
120 |                 this.progress.value = this.offset / this.blob.size;
121 |             }
122 |             this.li.removeChild(this.progress);
123 |             return;
124 |         }
125 |     }
126 | }
127 | class ServiceWorkerDownload {
128 |     constructor(sw, header) {
129 |         this.offset = 0;
130 |         this.li = document.createElement("li");
131 |         this.a = document.createElement("a");
132 |         this.progress = document.createElement("progress");
133 |         this.sw = sw;
134 |         this.header = header;
135 |         (this.id = `${Math.random().toString(16).substring(2)}-${encodeURIComponent(header.name)}`),
136 |             this.a.appendChild(document.createTextNode(`${header.name}`));
137 |         this.li.appendChild(this.a);
138 |         this.li.appendChild(this.progress);
139 |         this.li.classList.add("download");
140 |         transfersList.appendChild(this.li);
141 |         sw.postMessage({
142 |             id: this.id,
143 |             type: "metadata",
144 |             name: header.name,
145 |             size: header.size,
146 |             filetype: header.type,
147 |         });
148 |         this.triggerDownload();
149 |     }
150 |     receive(e) {
151 |         const chunkSize = e.data.byteLength;
152 |         if (this.offset + chunkSize > this.header.size) {
153 |             const error = "received more bytes than expected";
154 |             this.sw.postMessage({ id: this.id, type: "error", error });
155 |             throw error;
156 |         }
157 |         this.sw.postMessage({
158 |             id: this.id,
159 |             type: "data",
160 |             data: e.data,
161 |             offset: this.offset,
162 |         }, [e.data]);
163 |         this.offset += chunkSize;
164 |         this.progress.value = this.offset / this.header.size;
165 |         if (this.done()) {
166 |             this.sw.postMessage({ id: this.id, type: "end" });
167 |             this.li.removeChild(this.progress);
168 |         }
169 |     }
170 |     done() {
171 |         return this.offset === this.header.size;
172 |     }
173 |     cancel() {
174 |         this.sw.postMessage({
175 |             id: this.id,
176 |             type: "error",
177 |             error: "rtc disconnected",
178 |         });
179 |     }
180 |     triggerDownload() {
181 |         // `<a download=...>` doesn't work with service workers on Chrome yet.
182 |         // See https://bugs.chromium.org/p/chromium/issues/detail?id=468227
183 |         //
184 |         // Possible solutions:
185 |         //
186 |         // - `window.open` is blocked as a popup.
187 |         // window.open(`${SW_PREFIX}/${this.id}`);
188 |         //
189 |         // - And this is quite scary but `Content-Disposition` to the rescue!
190 |         //   It will navigate to 404 page if there is no service worker for some reason...
191 |         //   But if `postMessage` didn't throw we should be safe.
192 |         window.location.assign(`/_/${this.id}`);
193 |     }
194 | }
195 | class ArrayBufferDownload {
196 |     constructor(header) {
197 |         this.offset = 0;
198 |         this.li = document.createElement("li");
199 |         this.a = document.createElement("a");
200 |         this.progress = document.createElement("progress");
201 |         this.header = header;
202 |         this.data = new Uint8Array(header.size);
203 |         this.a.appendChild(document.createTextNode(`${header.name}`));
204 |         this.li.appendChild(this.a);
205 |         this.li.appendChild(this.progress);
206 |         this.li.classList.add("download");
207 |         transfersList.appendChild(this.li);
208 |     }
209 |     receive(e) {
210 |         const chunkSize = e.data.byteLength;
211 |         if (this.offset + chunkSize > this.header.size) {
212 |             const error = "received more bytes than expected";
213 |             throw error;
214 |         }
215 |         this.data.set(new Uint8Array(e.data), this.offset);
216 |         this.offset += chunkSize;
217 |         this.progress.value = this.offset / this.header.size;
218 |         if (this.done()) {
219 |             this.triggerDownload();
220 |             this.li.removeChild(this.progress);
221 |         }
222 |     }
223 |     done() {
224 |         return this.offset === this.header.size;
225 |     }
226 |     cancel() { }
227 |     triggerDownload() {
228 |         if (hacks.noblob) {
229 |             const blob = new Blob([this.data], { type: this.header.type });
230 |             const fr = new FileReader();
231 |             fr.onloadend = () => {
232 |                 this.a.href = fr.result;
233 |                 this.a.download = this.header.name;
234 |             };
235 |             fr.readAsDataURL(blob);
236 |             return;
237 |         }
238 |         const blob = new Blob([this.data], { type: this.header.type });
239 |         this.a.href = URL.createObjectURL(blob);
240 |         this.a.download = this.header.name;
241 |         this.a.click();
242 |     }
243 | }
244 | function pick() {
245 |     if (!filepicker.files) {
246 |         return;
247 |     }
248 |     for (let i = 0; i < filepicker.files.length; i++) {
249 |         sendfile(filepicker.files[i]);
250 |     }
251 | }
252 | function drop(e) {
253 |     if (!e.dataTransfer) {
254 |         return;
255 |     }
256 |     const files = e.dataTransfer.files;
257 |     const t = e.dataTransfer.getData("text");
258 |     if (files.length !== 0) {
259 |         for (let i = 0; i < files.length; i++) {
260 |             sendfile(files[i]);
261 |         }
262 |     }
263 |     else if (t.length !== 0) {
264 |         sendtext(t);
265 |     }
266 |     // A shortcut to save users a click. If we're disconnected and they drag
267 |     // a file in treat it as a click on the new/join wormhole button.
268 |     if (state === "disconnected") {
269 |         connect();
270 |     }
271 | }
272 | // Handle a paste event from cmd-v/ctl-v.
273 | function pasteEvent(e) {
274 |     if (!e.clipboardData) {
275 |         return;
276 |     }
277 |     const files = e.clipboardData.files;
278 |     const t = e.clipboardData.getData("text");
279 |     if (files.length !== 0) {
280 |         for (let i = 0; i < files.length; i++) {
281 |             sendfile(files[i]);
282 |         }
283 |     }
284 |     else if (t.length !== 0) {
285 |         sendtext(t);
286 |     }
287 | }
288 | // Read clipboard content using Clipboard API.
289 | async function pasteClipboard() {
290 |     if (hacks.noclipboardapi) {
291 |         return;
292 |     }
293 |     let items = await navigator.clipboard.read();
294 |     // TODO toast a message if permission wasn't given.
295 |     for (let i = 0; i < items.length; i++) {
296 |         if (items[i].types.includes("image/png")) {
297 |             const blob = await items[i].getType("image/png");
298 |             sendfile(new File([blob], "image.png"));
299 |         }
300 |         else if (items[i].types.includes("text/plain")) {
301 |             const blob = await items[i].getType("text/plain");
302 |             sendtext(await blob.text());
303 |         }
304 |     }
305 | }
306 | async function sendtext(msg) {
307 |     const item = new Upload({
308 |         name: msg,
309 |         type: "application/webwormhole-text",
310 |         size: 0,
311 |     }, new Blob([]));
312 |     item.li.classList.add("pending");
313 |     item.li.appendChild(document.createElement("pre").appendChild(document.createTextNode(`${msg}`)));
314 |     transfersList.appendChild(item.li);
315 |     send(item);
316 | }
317 | async function sendfile(f) {
318 |     const item = new Upload({
319 |         name: f.name,
320 |         type: f.type,
321 |         size: f.size,
322 |     }, f);
323 |     item.li.classList.add("pending");
324 |     item.li.innerText = `${f.name}`;
325 |     transfersList.appendChild(item.li);
326 |     send(item);
327 | }
328 | async function send(item) {
329 |     if (item) {
330 |         sendqueue.push(item);
331 |     }
332 |     if (!datachannel) {
333 |         console.log("adding to queue: not connected");
334 |         return;
335 |     }
336 |     if (sending) {
337 |         console.log("adding to queue: haven't finished sending current file");
338 |         return;
339 |     }
340 |     while ((sending = sendqueue.shift())) {
341 |         await sending.send(datachannel);
342 |         sending = undefined;
343 |     }
344 | }
345 | function receive(e) {
346 |     if (receiving) {
347 |         receiving.receive(e);
348 |         if (receiving.done()) {
349 |             receiving = undefined;
350 |         }
351 |         return;
352 |     }
353 |     const header = JSON.parse(new TextDecoder("utf8").decode(e.data));
354 |     // Special case raw text that's been received.
355 |     if (header.type === "application/webwormhole-text") {
356 |         const li = document.createElement("li");
357 |         li.appendChild(document
358 |             .createElement("pre")
359 |             .appendChild(document.createTextNode(`${header.name}`)));
360 |         li.classList.add("download");
361 |         transfersList.appendChild(li);
362 |         return;
363 |     }
364 |     if (serviceworker) {
365 |         receiving = new ServiceWorkerDownload(serviceworker, header);
366 |     }
367 |     else {
368 |         receiving = new ArrayBufferDownload(header);
369 |     }
370 | }
371 | async function connect() {
372 |     try {
373 |         dialling();
374 |         const w = new Wormhole(signalserver.href, phraseInput.value);
375 |         w.callback = (pc, code) => {
376 |             if (code) {
377 |                 waiting();
378 |                 codechange();
379 |                 phraseInput.value = code;
380 |                 location.hash = code;
381 |                 signalserver.hash = code;
382 |                 updateqr(signalserver.href);
383 |             }
384 |             peerconnection = pc;
385 |             // Use PeerConnection.iceConnectionState since Firefox does not
386 |             // implement PeerConnection.connectionState
387 |             pc.oniceconnectionstatechange = () => {
388 |                 switch (pc.iceConnectionState) {
389 |                     case "connected": {
390 |                         // Handled in datachannel.onopen.
391 |                         w.close();
392 |                         break;
393 |                     }
394 |                     case "disconnected":
395 |                     case "closed": {
396 |                         disconnected("webrtc connection closed");
397 |                         pc.onconnectionstatechange = null;
398 |                         break;
399 |                     }
400 |                     case "failed": {
401 |                         disconnected("webrtc connection failed");
402 |                         console.log("webrtc connection failed connectionState:", pc.connectionState, "iceConnectionState", pc.iceConnectionState);
403 |                         w.close();
404 |                         break;
405 |                     }
406 |                 }
407 |             };
408 |             const dc = pc.createDataChannel("data", { negotiated: true, id: 0 });
409 |             dc.onopen = () => {
410 |                 connected();
411 |                 datachannel = dc;
412 |                 // Send anything we have waiting in the send queue.
413 |                 send();
414 |             };
415 |             dc.onmessage = receive;
416 |             dc.binaryType = "arraybuffer";
417 |             dc.onclose = () => {
418 |                 disconnected("datachannel closed");
419 |             };
420 |             dc.onerror = e => {
421 |                 disconnected(`datachannel error: ${e}`);
422 |             };
423 |         };
424 |         const fingerprint = await w.dial();
425 |         // To make it more likely to spot the 1 in 2^16 chance of a successful
426 |         // MITM password guess, we can compare a fingerprint derived from the PAKE
427 |         // key. The 7 words visible on the tooltip of the input box should match on
428 |         // both side.
429 |         // We also use the first 3 bits of it to choose the background colour, so
430 |         // that should match on both sides as well.
431 |         const encodedfp = webwormhole.encode(0, fingerprint.subarray(1));
432 |         phraseInput.title = encodedfp.substring(encodedfp.indexOf("-") + 1);
433 |         document.body.style.backgroundColor = `var(--palette-${fingerprint[0] % 8})`;
434 |     }
435 |     catch (err) {
436 |         if (err instanceof Error) {
437 |             disconnected(err.toString());
438 |         }
439 |         else if (typeof err === "string") {
440 |             disconnected(err);
441 |         }
442 |     }
443 | }
444 | function waiting() {
445 |     infoBox.innerText =
446 |         "Waiting for the other side to join by typing the wormhole phrase, opening this URL, or scanning the QR code.";
447 | }
448 | function dialling() {
449 |     state = "dialling";
450 |     infoBox.innerText = "Connecting...";
451 |     document.body.classList.add("dialling");
452 |     document.body.classList.remove("connected");
453 |     document.body.classList.remove("disconnected");
454 |     filepicker.disabled = false;
455 |     clipboardInput.disabled = false || hacks.noclipboardapi;
456 |     dialButton.disabled = true;
457 |     phraseInput.readOnly = true;
458 |     document.body.addEventListener("paste", pasteEvent);
459 | }
460 | function connected() {
461 |     state = "connected";
462 |     infoBox.innerText = "";
463 |     document.body.classList.remove("dialling");
464 |     document.body.classList.add("connected");
465 |     document.body.classList.remove("disconnected");
466 |     location.hash = "";
467 | }
468 | function disconnected(reason) {
469 |     state = "disconnected";
470 |     datachannel = null;
471 |     sendqueue = [];
472 |     document.body.style.backgroundColor = "";
473 |     // TODO better error types or at least hoist the strings to consts.
474 |     if (reason === "bad key") {
475 |         infoBox.innerText = "Wrong wormhole phrase.";
476 |     }
477 |     else if (reason === "bad code") {
478 |         infoBox.innerText = "Not a valid wormhole phrase.";
479 |     }
480 |     else if (reason === "no such slot") {
481 |         infoBox.innerText = "No such slot. The wormhole might have expired.";
482 |     }
483 |     else if (reason === "timed out") {
484 |         infoBox.innerText = "Wormhole expired.";
485 |     }
486 |     else if (reason === "could not connect to signalling server") {
487 |         infoBox.innerText =
488 |             "Could not reach the signalling server. Refresh page and try again.";
489 |     }
490 |     else if (reason === "webrtc connection closed") {
491 |         infoBox.innerText = "Disconnected.";
492 |     }
493 |     else if (reason === "webrtc connection failed") {
494 |         infoBox.innerText = "Network error.";
495 |     }
496 |     else if (reason === "datachannel closed") {
497 |         infoBox.innerText = "Disconnected.";
498 |     }
499 |     else if (reason === "webrtc connection failed") {
500 |         infoBox.innerText = "Network error.";
501 |     }
502 |     else {
503 |         infoBox.innerText = "Could not connect.";
504 |         console.log(reason);
505 |     }
506 |     document.body.classList.remove("dialling");
507 |     document.body.classList.remove("connected");
508 |     document.body.classList.add("disconnected");
509 |     filepicker.disabled = true;
510 |     clipboardInput.disabled = true;
511 |     document.body.removeEventListener("paste", pasteEvent);
512 |     dialButton.disabled = false;
513 |     phraseInput.readOnly = false;
514 |     phraseInput.value = "";
515 |     codechange();
516 |     updateqr("");
517 |     location.hash = "";
518 |     if (receiving) {
519 |         receiving.cancel();
520 |         receiving = undefined;
521 |     }
522 | }
523 | function highlight() {
524 |     document.body.classList.add("highlight");
525 | }
526 | function unhighlight() {
527 |     document.body.classList.remove("highlight");
528 | }
529 | function preventdefault(e) {
530 |     e.preventDefault();
531 |     e.stopPropagation();
532 | }
533 | async function copyurl() {
534 |     await navigator.clipboard.writeText(signalserver.href);
535 |     // TODO toast message on success.
536 | }
537 | function updateqr(url) {
538 |     const qr = webwormhole.qrencode(url);
539 |     if (url === "" || qr === null) {
540 |         qrImg.src = "";
541 |         qrImg.alt = "";
542 |         qrImg.title = "";
543 |     }
544 |     else {
545 |         qrImg.src = URL.createObjectURL(new Blob([qr]));
546 |         qrImg.alt = url;
547 |         qrImg.title = `${url} - double click to copy`;
548 |     }
549 | }
550 | function hashchange() {
551 |     const newhash = location.hash.substring(1);
552 |     if (newhash !== "" && newhash !== phraseInput.value) {
553 |         console.log("hash changed dialling new code");
554 |         phraseInput.value = newhash;
555 |         codechange();
556 |         connect();
557 |     }
558 | }
559 | function codechange() {
560 |     if (phraseInput.value === "") {
561 |         dialButton.value = "CREATE WORMHOLE";
562 |     }
563 |     else {
564 |         dialButton.value = "JOIN WORMHOLE";
565 |     }
566 | }
567 | function autocompletehint() {
568 |     const words = phraseInput.value.split("-");
569 |     const prefix = words[words.length - 1];
570 |     const hint = webwormhole.match(prefix);
571 |     autocompleteBox.innerText = hint;
572 | }
573 | function autocomplete(e) {
574 |     // TODO more stateful autocomplete, i.e. repeated tabs cycle through matches.
575 |     if (e.keyCode === 9) {
576 |         e.preventDefault(); // Prevent tabs from doing tab things.
577 |         const words = phraseInput.value.split("-");
578 |         const prefix = words[words.length - 1];
579 |         const hint = webwormhole.match(prefix);
580 |         if (hint === "") {
581 |             return;
582 |         }
583 |         phraseInput.value += `${hint.substring(prefix.length)}-`;
584 |         autocompleteBox.innerText = "";
585 |     }
586 | }
587 | function browserhacks() {
588 |     // Detect for features we need for this to work.
589 |     if (!window.WebSocket || !window.RTCPeerConnection || !window.WebAssembly) {
590 |         hacks.browserunsupported = true;
591 |         hacks.nosw = true;
592 |         hacks.nowasm = true;
593 |         console.log("quirks: browser not supported");
594 |         console.log("websocket:", !!window.WebSocket, "webrtc:", !!window.RTCPeerConnection, "wasm:", !!window.WebAssembly);
595 |         return;
596 |     }
597 |     // Polyfill for Safari WASM streaming.
598 |     if (!WebAssembly.instantiateStreaming) {
599 |         WebAssembly.instantiateStreaming = async (resp, importObject) => {
600 |             const source = await (await resp).arrayBuffer();
601 |             return await WebAssembly.instantiate(source, importObject);
602 |         };
603 |         console.log("quirks: using wasm streaming polyfill");
604 |     }
605 |     // Safari cannot save files from service workers.
606 |     if (/Safari/.test(navigator.userAgent) &&
607 |         !(/Chrome/.test(navigator.userAgent) || /Chromium/.test(navigator.userAgent))) {
608 |         hacks.nosw = true;
609 |         console.log("quirks: serviceworkers disabled on safari");
610 |     }
611 |     if (!navigator.serviceWorker) {
612 |         hacks.nosw = true;
613 |         console.log("quirks: no serviceworkers");
614 |     }
615 |     // Work around iOS Safari <= 12 not being able to download blob URLs.
616 |     // This can die when iOS Safari usage is less than 1% on this table:
617 |     // https://caniuse.com/usage-table
618 |     hacks.noblob = false;
619 |     if (/^Mozilla\/5.0 \(iPhone; CPU iPhone OS 12_[0-9]_[0-9] like Mac OS X\)/.test(navigator.userAgent)) {
620 |         hacks.noblob = true;
621 |         hacks.nosw = true;
622 |         console.log("quirks: using ios12 dataurl hack");
623 |     }
624 |     // Work around iOS trying to connect when the link is previewed.
625 |     // You never saw this.
626 |     if (/iPad|iPhone|iPod/.test(navigator.userAgent) &&
627 |         ![320, 375, 414, 768, 1024].includes(window.innerWidth)) {
628 |         hacks.noautoconnect = true;
629 |         console.log("quirks: detected ios page preview");
630 |     }
631 |     // Firefox does not support clipboard.read.
632 |     if (!navigator.clipboard || !navigator.clipboard.read) {
633 |         hacks.noclipboardapi = true;
634 |         console.log("quirks: clipboard api not supported");
635 |     }
636 |     // Are we in an extension?
637 |     if (window.chrome && chrome.runtime) {
638 |         hacks.ext = true;
639 |         hacks.nosw = true;
640 |         console.log("quirks: browser extension");
641 |     }
642 | }
643 | async function domready() {
644 |     return new Promise((resolve) => {
645 |         document.addEventListener("DOMContentLoaded", resolve);
646 |     });
647 | }
648 | async function swready() {
649 |     if (!hacks.nosw) {
650 |         // Remove old /_/ scoped service worker.
651 |         const regs = await navigator.serviceWorker.getRegistrations();
652 |         for (let i = 0; i < regs.length; i++) {
653 |             if (regs[i].scope.endsWith("/_/")) {
654 |                 regs[i].unregister();
655 |             }
656 |         }
657 |         // The scope has to be "/" and not just "/_/" in order to meet Chrome's
658 |         // PWA installability criteria.
659 |         const reg = await navigator.serviceWorker.register("sw.js", { scope: "/" });
660 |         serviceworker = reg.active || reg.waiting || reg.installing;
661 |         // Add a listener for Share Target API requests forwarded from service worker.
662 |         // This doesn't seem to actually work, and it's quite difficult to debug. We
663 |         // might remove it soon.
664 |         navigator.serviceWorker.addEventListener("message", (e) => {
665 |             const msg = e.data;
666 |             const item = new Upload({
667 |                 name: msg.name,
668 |                 type: msg.type,
669 |                 size: msg.size,
670 |             }, msg.stream);
671 |             item.li.classList.add("pending");
672 |             item.li.innerText = `${msg.name}`;
673 |             transfersList.appendChild(item.li);
674 |             send(item);
675 |             if (state === "disconnected") {
676 |                 connect();
677 |             }
678 |         });
679 |         if (serviceworker) {
680 |             console.log("service worker registered:", serviceworker.state);
681 |         }
682 |     }
683 | }
684 | async function wasmready(wasmURL) {
685 |     if (!hacks.nowasm) {
686 |         const go = new Go();
687 |         const wasm = await WebAssembly.instantiateStreaming(fetch(wasmURL), go.importObject);
688 |         go.run(wasm.instance);
689 |     }
690 | }
691 | async function init() {
692 |     // Detect Browser Quirks.
693 |     browserhacks();
694 |     let wasmURL = "webwormhole.wasm";
695 |     if (hacks.ext) {
696 |         signalserver = new URL("https://webwormhole.io/");
697 |         wasmURL = chrome.runtime.getURL("webwormhole.wasm");
698 |     }
699 |     // Wait for the ServiceWorker, WebAssembly, and DOM to be ready.
700 |     await Promise.all([domready(), swready(), wasmready(wasmURL)]);
701 |     // Wireup HTML.
702 |     filepicker = document.getElementById("filepicker");
703 |     dialButton = document.getElementById("dial");
704 |     phraseInput = document.getElementById("magiccode");
705 |     clipboardInput = document.getElementById("clipboard");
706 |     mainForm = document.getElementById("main");
707 |     qrImg = document.getElementById("qr");
708 |     transfersList = document.getElementById("transfers");
709 |     infoBox = document.getElementById("info");
710 |     autocompleteBox = document.getElementById("autocomplete");
711 |     // Friendly error message and bail out if things are clearely not going to work.
712 |     if (hacks.browserunsupported) {
713 |         infoBox.innerText =
714 |             "Browser missing required feature. This application needs support for WebSockets, WebRTC, and WebAssembly.";
715 |         document.body.classList.add("error");
716 |         return;
717 |     }
718 |     // Install event handlers. If we start to allow queueing files before
719 |     // connections we might want to move these into domready so as to not
720 |     // block them.
721 |     window.addEventListener("hashchange", hashchange);
722 |     phraseInput.addEventListener("input", codechange);
723 |     phraseInput.addEventListener("keydown", autocomplete);
724 |     phraseInput.addEventListener("input", autocompletehint);
725 |     filepicker.addEventListener("change", pick);
726 |     clipboardInput.addEventListener("click", pasteClipboard);
727 |     mainForm.addEventListener("submit", preventdefault);
728 |     mainForm.addEventListener("submit", connect);
729 |     qrImg.addEventListener("dblclick", copyurl);
730 |     document.body.addEventListener("drop", preventdefault);
731 |     document.body.addEventListener("dragenter", preventdefault);
732 |     document.body.addEventListener("dragover", preventdefault);
733 |     document.body.addEventListener("drop", preventdefault);
734 |     document.body.addEventListener("dragleave", preventdefault);
735 |     document.body.addEventListener("drop", drop);
736 |     document.body.addEventListener("dragenter", highlight);
737 |     document.body.addEventListener("dragover", highlight);
738 |     document.body.addEventListener("drop", unhighlight);
739 |     document.body.addEventListener("dragleave", unhighlight);
740 |     if (location.hash.substring(1) !== "") {
741 |         phraseInput.value = location.hash.substring(1);
742 |     }
743 |     codechange(); // User might have typed something while we were loading.
744 |     dialButton.disabled = false;
745 |     if (!hacks.noautoconnect && phraseInput.value !== "") {
746 |         connect();
747 |     }
748 | }
749 | init();
750 | 


--------------------------------------------------------------------------------
/web/main.ts:
--------------------------------------------------------------------------------
  1 | /// <reference path="ww.ts" />
  2 | 
  3 | // Declare just enough of the extensions API to find out if we're
  4 | // running in the context of one.
  5 | interface Window {
  6 | 	chrome: typeof chrome;
  7 | }
  8 | declare namespace chrome.runtime {
  9 | 	export function getURL(path: string): string;
 10 | }
 11 | 
 12 | // Flags corresponding to browser specific quirks.
 13 | const hacks: Record<string, boolean> = {};
 14 | 
 15 | // receiving is the object currently being received.
 16 | let receiving: Receiver | undefined;
 17 | 
 18 | // sending is the object currently being sent.
 19 | let sending: Upload | undefined;
 20 | 
 21 | // sendqueue is the queue of objects waiting to be sent.
 22 | let sendqueue: Upload[] = [];
 23 | 
 24 | // state is the top-level connection state.
 25 | let state: "disconnected" | "dialling" | "connected" = "disconnected";
 26 | 
 27 | // datachannel is the active datachannel, if we're connected.
 28 | let datachannel: RTCDataChannel | null;
 29 | 
 30 | // serviceworker is the helper download service worker, if enabled.
 31 | let serviceworker: ServiceWorker | null;
 32 | 
 33 | // signalserver is the address of the signalling server.
 34 | let signalserver: URL = new URL(location.href);
 35 | 
 36 | // peerconnection is the active connection's WebRTC object. Global to help debugging.
 37 | let peerconnection: RTCPeerConnection | null;
 38 | 
 39 | // UI elements.
 40 | let filepicker: HTMLInputElement;
 41 | let dialButton: HTMLInputElement;
 42 | let phraseInput: HTMLInputElement;
 43 | let clipboardInput: HTMLInputElement;
 44 | let mainForm: HTMLFormElement;
 45 | let qrImg: HTMLImageElement;
 46 | let transfersList: HTMLElement;
 47 | let infoBox: HTMLElement;
 48 | let autocompleteBox: HTMLElement;
 49 | 
 50 | // The structure of the header message sent on the wire before a
 51 | // file's data.
 52 | interface FileHeader {
 53 | 	name: string;
 54 | 	type: string;
 55 | 	size: number;
 56 | }
 57 | 
 58 | interface Receiver {
 59 | 	receive(e: MessageEvent): void;
 60 | 	done(): boolean;
 61 | 	cancel(): void;
 62 | 
 63 | 	li: HTMLElement;
 64 | 	a: HTMLAnchorElement;
 65 | 	progress: HTMLProgressElement;
 66 | }
 67 | 
 68 | class DataChannelWriter {
 69 | 	dc: RTCDataChannel;
 70 | 
 71 | 	chunksize = 32 << 10;
 72 | 	bufferedAmountHighThreshold = 1 << 20;
 73 | 	bufferedAmountLowThreshold = 1 << 20;
 74 | 
 75 | 	ready: Promise<void>;
 76 | 	resolve?: () => void;
 77 | 
 78 | 	constructor(dc: RTCDataChannel) {
 79 | 		this.dc = dc;
 80 | 		this.dc.bufferedAmountLowThreshold = this.bufferedAmountLowThreshold;
 81 | 		this.dc.onbufferedamountlow = () => {
 82 | 			if (this.resolve) this.resolve();
 83 | 		};
 84 | 		this.ready = new Promise((resolve) => {
 85 | 			this.resolve = resolve; // TODO needed?
 86 | 			this.resolve();
 87 | 		});
 88 | 	}
 89 | 
 90 | 	async write(buf: Uint8Array) {
 91 | 		for (let offset = 0; offset < buf.length; offset += this.chunksize) {
 92 | 			let end = offset + this.chunksize;
 93 | 			if (end > buf.length) {
 94 | 				end = buf.length;
 95 | 			}
 96 | 			await this.ready;
 97 | 			this.dc.send(buf.subarray(offset, end));
 98 | 		}
 99 | 		if (this.dc.bufferedAmount >= this.bufferedAmountHighThreshold) {
100 | 			this.ready = new Promise((resolve) => {
101 | 				this.resolve = resolve;
102 | 			});
103 | 		}
104 | 	}
105 | }
106 | 
107 | class Upload {
108 | 	header: FileHeader;
109 | 	blob?: Blob;
110 | 	stream?: ReadableStream;
111 | 	offset = 0;
112 | 
113 | 	li: HTMLElement = document.createElement("li");
114 | 	progress: HTMLProgressElement = document.createElement("progress");
115 | 
116 | 	constructor(header: FileHeader, data: Blob | ReadableStream) {
117 | 		this.header = header;
118 | 		if (data instanceof ReadableStream) {
119 | 			this.stream = data;
120 | 		} else {
121 | 			this.blob = data;
122 | 			if (data.stream) {
123 | 				this.stream = data.stream();
124 | 			}
125 | 		}
126 | 	}
127 | 
128 | 	async send(dc: RTCDataChannel) {
129 | 		console.log("sending", this.header.name, this.header.type);
130 | 		this.li.classList.remove("pending");
131 | 		this.li.classList.add("upload");
132 | 		this.li.appendChild(document.createElement("progress"));
133 | 		this.progress = this.li.getElementsByTagName("progress")[0];
134 | 
135 | 		dc.send(new TextEncoder().encode(JSON.stringify(this.header)));
136 | 
137 | 		const writer = new DataChannelWriter(dc);
138 | 		if (this.stream) {
139 | 			const reader = this.stream.getReader();
140 | 			while (true) {
141 | 				const { done, value } = await reader.read();
142 | 				if (done) {
143 | 					break;
144 | 				}
145 | 				await writer.write(value);
146 | 				this.offset += value.length;
147 | 				this.progress.value = this.offset / this.header.size;
148 | 			}
149 | 			this.li.removeChild(this.progress);
150 | 			return;
151 | 		}
152 | 
153 | 		if (this.blob) {
154 | 			// Backwards compatability with browsers that don't have Blob.stream. (Safari pre-14.1)
155 | 			let read = (b: Blob): Promise<Uint8Array>  => {
156 | 				return new Promise((resolve) => {
157 | 					const fr = new FileReader();
158 | 					fr.onload = () => {
159 | 						resolve(new Uint8Array(fr.result as ArrayBuffer));
160 | 					};
161 | 					fr.readAsArrayBuffer(b);
162 | 				});
163 | 			}
164 | 			const chunksize = 64 << 10;
165 | 			while (this.offset < this.header.size) {
166 | 				let end = this.offset + chunksize;
167 | 				if (end > this.blob.size) {
168 | 					end = this.blob.size;
169 | 				}
170 | 				await writer.write(await read(this.blob.slice(this.offset, end)));
171 | 				this.offset = end;
172 | 				this.progress.value = this.offset / this.blob.size;
173 | 			}
174 | 			this.li.removeChild(this.progress);
175 | 			return;
176 | 		}
177 | 	}
178 | }
179 | 
180 | class ServiceWorkerDownload {
181 | 	header: FileHeader;
182 | 	id: string;
183 | 	sw: ServiceWorker;
184 | 	offset = 0;
185 | 
186 | 	li: HTMLElement = document.createElement("li");
187 | 	a: HTMLAnchorElement = document.createElement("a");
188 | 	progress: HTMLProgressElement = document.createElement("progress");
189 | 
190 | 	constructor(sw: ServiceWorker, header: FileHeader) {
191 | 		this.sw = sw;
192 | 		this.header = header;
193 | 		(this.id = `${Math.random().toString(16).substring(2)}-${encodeURIComponent(
194 | 			header.name
195 | 		)}`),
196 | 			this.a.appendChild(document.createTextNode(`${header.name}`));
197 | 		this.li.appendChild(this.a);
198 | 		this.li.appendChild(this.progress);
199 | 		this.li.classList.add("download");
200 | 		transfersList.appendChild(this.li);
201 | 
202 | 		sw.postMessage({
203 | 			id: this.id,
204 | 			type: "metadata", // TODO rename this to not clash with header.type
205 | 			name: header.name,
206 | 			size: header.size,
207 | 			filetype: header.type,
208 | 		});
209 | 
210 | 		this.triggerDownload();
211 | 	}
212 | 
213 | 	receive(e: MessageEvent) {
214 | 		const chunkSize = e.data.byteLength;
215 | 
216 | 		if (this.offset + chunkSize > this.header.size) {
217 | 			const error = "received more bytes than expected";
218 | 			this.sw.postMessage({ id: this.id, type: "error", error });
219 | 			throw error;
220 | 		}
221 | 
222 | 		this.sw.postMessage(
223 | 			{
224 | 				id: this.id,
225 | 				type: "data",
226 | 				data: e.data,
227 | 				offset: this.offset,
228 | 			},
229 | 			[e.data]
230 | 		);
231 | 
232 | 		this.offset += chunkSize;
233 | 		this.progress.value = this.offset / this.header.size;
234 | 
235 | 		if (this.done()) {
236 | 			this.sw.postMessage({ id: this.id, type: "end" });
237 | 			this.li.removeChild(this.progress);
238 | 		}
239 | 	}
240 | 
241 | 	done() {
242 | 		return this.offset === this.header.size;
243 | 	}
244 | 
245 | 	cancel() {
246 | 		this.sw.postMessage({
247 | 			id: this.id,
248 | 			type: "error",
249 | 			error: "rtc disconnected",
250 | 		});
251 | 	}
252 | 
253 | 	triggerDownload() {
254 | 		// `<a download=...>` doesn't work with service workers on Chrome yet.
255 | 		// See https://bugs.chromium.org/p/chromium/issues/detail?id=468227
256 | 		//
257 | 		// Possible solutions:
258 | 		//
259 | 		// - `window.open` is blocked as a popup.
260 | 		// window.open(`${SW_PREFIX}/${this.id}`);
261 | 		//
262 | 		// - And this is quite scary but `Content-Disposition` to the rescue!
263 | 		//   It will navigate to 404 page if there is no service worker for some reason...
264 | 		//   But if `postMessage` didn't throw we should be safe.
265 | 		window.location.assign(`/_/${this.id}`);
266 | 	}
267 | }
268 | 
269 | class ArrayBufferDownload {
270 | 	header: FileHeader;
271 | 	data: Uint8Array;
272 | 	offset = 0;
273 | 
274 | 	li: HTMLElement = document.createElement("li");
275 | 	a: HTMLAnchorElement = document.createElement("a");
276 | 	progress: HTMLProgressElement = document.createElement("progress");
277 | 
278 | 	constructor(header: FileHeader) {
279 | 		this.header = header;
280 | 		this.data = new Uint8Array(header.size);
281 | 		this.a.appendChild(document.createTextNode(`${header.name}`));
282 | 		this.li.appendChild(this.a);
283 | 		this.li.appendChild(this.progress);
284 | 		this.li.classList.add("download");
285 | 		transfersList.appendChild(this.li);
286 | 	}
287 | 
288 | 	receive(e: MessageEvent) {
289 | 		const chunkSize = e.data.byteLength;
290 | 
291 | 		if (this.offset + chunkSize > this.header.size) {
292 | 			const error = "received more bytes than expected";
293 | 			throw error;
294 | 		}
295 | 
296 | 		this.data.set(new Uint8Array(e.data), this.offset);
297 | 		this.offset += chunkSize;
298 | 		this.progress.value = this.offset / this.header.size;
299 | 
300 | 		if (this.done()) {
301 | 			this.triggerDownload();
302 | 			this.li.removeChild(this.progress);
303 | 		}
304 | 	}
305 | 
306 | 	done() {
307 | 		return this.offset === this.header.size;
308 | 	}
309 | 
310 | 	cancel() {}
311 | 
312 | 	triggerDownload() {
313 | 		if (hacks.noblob) {
314 | 			const blob = new Blob([this.data], { type: this.header.type });
315 | 			const fr = new FileReader();
316 | 			fr.onloadend = () => {
317 | 				this.a.href = fr.result as string;
318 | 				this.a.download = this.header.name;
319 | 			};
320 | 			fr.readAsDataURL(blob);
321 | 			return;
322 | 		}
323 | 
324 | 		const blob = new Blob([this.data], { type: this.header.type });
325 | 		this.a.href = URL.createObjectURL(blob);
326 | 		this.a.download = this.header.name;
327 | 		this.a.click();
328 | 	}
329 | }
330 | 
331 | function pick() {
332 | 	if (!filepicker.files) {
333 | 		return;
334 | 	}
335 | 	for (let i = 0; i < filepicker.files.length; i++) {
336 | 		sendfile(filepicker.files[i]);
337 | 	}
338 | }
339 | 
340 | function drop(e: DragEvent) {
341 | 	if (!e.dataTransfer) {
342 | 		return;
343 | 	}
344 | 	const files = e.dataTransfer.files;
345 | 	const t = e.dataTransfer.getData("text");
346 | 	if (files.length !== 0) {
347 | 		for (let i = 0; i < files.length; i++) {
348 | 			sendfile(files[i]);
349 | 		}
350 | 	} else if (t.length !== 0) {
351 | 		sendtext(t);
352 | 	}
353 | 
354 | 	// A shortcut to save users a click. If we're disconnected and they drag
355 | 	// a file in treat it as a click on the new/join wormhole button.
356 | 	if (state === "disconnected") {
357 | 		connect();
358 | 	}
359 | }
360 | 
361 | // Handle a paste event from cmd-v/ctl-v.
362 | function pasteEvent(e: ClipboardEvent) {
363 | 	if (!e.clipboardData) {
364 | 		return;
365 | 	}
366 | 	const files = e.clipboardData.files;
367 | 	const t = e.clipboardData.getData("text");
368 | 	if (files.length !== 0) {
369 | 		for (let i = 0; i < files.length; i++) {
370 | 			sendfile(files[i]);
371 | 		}
372 | 	} else if (t.length !== 0) {
373 | 		sendtext(t);
374 | 	}
375 | }
376 | 
377 | // Read clipboard content using Clipboard API.
378 | async function pasteClipboard() {
379 | 	if (hacks.noclipboardapi) {
380 | 		return;
381 | 	}
382 | 
383 | 	let items = await navigator.clipboard.read();
384 | 
385 | 	// TODO toast a message if permission wasn't given.
386 | 	for (let i = 0; i < items.length; i++) {
387 | 		if (items[i].types.includes("image/png")) {
388 | 			const blob = await items[i].getType("image/png");
389 | 			sendfile(new File([blob], "image.png"));
390 | 		} else if (items[i].types.includes("text/plain")) {
391 | 			const blob = await items[i].getType("text/plain");
392 | 			sendtext(await blob.text());
393 | 		}
394 | 	}
395 | }
396 | 
397 | async function sendtext(msg: string) {
398 | 	const item = new Upload(
399 | 		{
400 | 			name: msg,
401 | 			type: "application/webwormhole-text",
402 | 			size: 0,
403 | 		},
404 | 		new Blob([])
405 | 	);
406 | 	item.li.classList.add("pending");
407 | 	item.li.appendChild(
408 | 		document.createElement("pre").appendChild(document.createTextNode(`${msg}`))
409 | 	);
410 | 	transfersList.appendChild(item.li);
411 | 	send(item);
412 | }
413 | 
414 | async function sendfile(f: File) {
415 | 	const item = new Upload(
416 | 		{
417 | 			name: f.name,
418 | 			type: f.type,
419 | 			size: f.size,
420 | 		},
421 | 		f
422 | 	);
423 | 	item.li.classList.add("pending");
424 | 	item.li.innerText = `${f.name}`;
425 | 	transfersList.appendChild(item.li);
426 | 	send(item);
427 | }
428 | 
429 | async function send(item?: Upload) {
430 | 	if (item) {
431 | 		sendqueue.push(item);
432 | 	}
433 | 	if (!datachannel) {
434 | 		console.log("adding to queue: not connected");
435 | 		return;
436 | 	}
437 | 	if (sending) {
438 | 		console.log("adding to queue: haven't finished sending current file");
439 | 		return;
440 | 	}
441 | 	while ((sending = sendqueue.shift())) {
442 | 		await sending.send(datachannel);
443 | 		sending = undefined;
444 | 	}
445 | }
446 | 
447 | function receive(e: MessageEvent) {
448 | 	if (receiving) {
449 | 		receiving.receive(e);
450 | 		if (receiving.done()) {
451 | 			receiving = undefined;
452 | 		}
453 | 		return;
454 | 	}
455 | 
456 | 	const header = JSON.parse(
457 | 		new TextDecoder("utf8").decode(e.data)
458 | 	) as FileHeader;
459 | 
460 | 	// Special case raw text that's been received.
461 | 	if (header.type === "application/webwormhole-text") {
462 | 		const li = document.createElement("li");
463 | 		li.appendChild(
464 | 			document
465 | 				.createElement("pre")
466 | 				.appendChild(document.createTextNode(`${header.name}`))
467 | 		);
468 | 		li.classList.add("download");
469 | 		transfersList.appendChild(li);
470 | 		return;
471 | 	}
472 | 
473 | 	if (serviceworker) {
474 | 		receiving = new ServiceWorkerDownload(serviceworker, header);
475 | 	} else {
476 | 		receiving = new ArrayBufferDownload(header);
477 | 	}
478 | }
479 | 
480 | async function connect() {
481 | 	try {
482 | 		dialling();
483 | 
484 | 		const w = new Wormhole(signalserver.href, phraseInput.value);
485 | 
486 | 		w.callback = (pc: RTCPeerConnection, code?: string) => {
487 | 			if (code) {
488 | 				waiting();
489 | 				codechange();
490 | 				phraseInput.value = code;
491 | 				location.hash = code;
492 | 				signalserver.hash = code;
493 | 				updateqr(signalserver.href);
494 | 			}
495 | 
496 | 			peerconnection = pc;
497 | 
498 | 			// Use PeerConnection.iceConnectionState since Firefox does not
499 | 			// implement PeerConnection.connectionState
500 | 			pc.oniceconnectionstatechange = () => {
501 | 				switch (pc.iceConnectionState) {
502 | 					case "connected": {
503 | 						// Handled in datachannel.onopen.
504 | 						w.close();
505 | 						break;
506 | 					}
507 | 					case "disconnected":
508 | 					case "closed": {
509 | 						disconnected("webrtc connection closed");
510 | 						pc.onconnectionstatechange = null;
511 | 						break;
512 | 					}
513 | 					case "failed": {
514 | 						disconnected("webrtc connection failed");
515 | 						console.log(
516 | 							"webrtc connection failed connectionState:",
517 | 							pc.connectionState,
518 | 							"iceConnectionState",
519 | 							pc.iceConnectionState
520 | 						);
521 | 						w.close();
522 | 						break;
523 | 					}
524 | 				}
525 | 			};
526 | 
527 | 			const dc = pc.createDataChannel("data", { negotiated: true, id: 0 });
528 | 			dc.onopen = () => {
529 | 				connected();
530 | 				datachannel = dc;
531 | 				// Send anything we have waiting in the send queue.
532 | 				send();
533 | 			};
534 | 			dc.onmessage = receive;
535 | 			dc.binaryType = "arraybuffer";
536 | 			dc.onclose = () => {
537 | 				disconnected("datachannel closed");
538 | 			};
539 | 			dc.onerror = e => {
540 | 				disconnected(`datachannel error: ${e}`);
541 | 			};
542 | 		};
543 | 
544 | 		const fingerprint = await w.dial();
545 | 
546 | 		// To make it more likely to spot the 1 in 2^16 chance of a successful
547 | 		// MITM password guess, we can compare a fingerprint derived from the PAKE
548 | 		// key. The 7 words visible on the tooltip of the input box should match on
549 | 		// both side.
550 | 		// We also use the first 3 bits of it to choose the background colour, so
551 | 		// that should match on both sides as well.
552 | 		const encodedfp = webwormhole.encode(0, fingerprint.subarray(1));
553 | 		phraseInput.title = encodedfp.substring(encodedfp.indexOf("-") + 1);
554 | 		document.body.style.backgroundColor = `var(--palette-${
555 | 			fingerprint[0] % 8
556 | 		})`;
557 | 	} catch (err) {
558 | 		if (err instanceof Error) {
559 | 			disconnected(err.toString());
560 | 		} else if (typeof err === "string") {
561 | 			disconnected(err);
562 | 		}
563 | 	}
564 | }
565 | 
566 | function waiting() {
567 | 	infoBox.innerText =
568 | 		"Waiting for the other side to join by typing the wormhole phrase, opening this URL, or scanning the QR code.";
569 | }
570 | 
571 | function dialling() {
572 | 	state = "dialling";
573 | 	infoBox.innerText = "Connecting...";
574 | 
575 | 	document.body.classList.add("dialling");
576 | 	document.body.classList.remove("connected");
577 | 	document.body.classList.remove("disconnected");
578 | 
579 | 	filepicker.disabled = false;
580 | 	clipboardInput.disabled = false || hacks.noclipboardapi;
581 | 	dialButton.disabled = true;
582 | 	phraseInput.readOnly = true;
583 | 	document.body.addEventListener("paste", pasteEvent);
584 | }
585 | 
586 | function connected() {
587 | 	state = "connected";
588 | 	infoBox.innerText = "";
589 | 
590 | 	document.body.classList.remove("dialling");
591 | 	document.body.classList.add("connected");
592 | 	document.body.classList.remove("disconnected");
593 | 
594 | 	location.hash = "";
595 | }
596 | 
597 | function disconnected(reason: string) {
598 | 	state = "disconnected";
599 | 	datachannel = null;
600 | 	sendqueue = [];
601 | 	document.body.style.backgroundColor = "";
602 | 
603 | 	// TODO better error types or at least hoist the strings to consts.
604 | 	if (reason === "bad key") {
605 | 		infoBox.innerText = "Wrong wormhole phrase.";
606 | 	} else if (reason === "bad code") {
607 | 		infoBox.innerText = "Not a valid wormhole phrase.";
608 | 	} else if (reason === "no such slot") {
609 | 		infoBox.innerText = "No such slot. The wormhole might have expired.";
610 | 	} else if (reason === "timed out") {
611 | 		infoBox.innerText = "Wormhole expired.";
612 | 	} else if (reason === "could not connect to signalling server") {
613 | 		infoBox.innerText =
614 | 			"Could not reach the signalling server. Refresh page and try again.";
615 | 	} else if (reason === "webrtc connection closed") {
616 | 		infoBox.innerText = "Disconnected.";
617 | 	} else if (reason === "webrtc connection failed") {
618 | 		infoBox.innerText = "Network error.";
619 | 	} else if (reason === "datachannel closed") {
620 | 		infoBox.innerText = "Disconnected.";
621 | 	} else if (reason === "webrtc connection failed") {
622 | 		infoBox.innerText = "Network error.";
623 | 	} else {
624 | 		infoBox.innerText = "Could not connect.";
625 | 		console.log(reason);
626 | 	}
627 | 
628 | 	document.body.classList.remove("dialling");
629 | 	document.body.classList.remove("connected");
630 | 	document.body.classList.add("disconnected");
631 | 
632 | 	filepicker.disabled = true;
633 | 	clipboardInput.disabled = true;
634 | 	document.body.removeEventListener("paste", pasteEvent);
635 | 	dialButton.disabled = false;
636 | 	phraseInput.readOnly = false;
637 | 	phraseInput.value = "";
638 | 	codechange();
639 | 	updateqr("");
640 | 
641 | 	location.hash = "";
642 | 
643 | 	if (receiving) {
644 | 		receiving.cancel();
645 | 		receiving = undefined;
646 | 	}
647 | }
648 | 
649 | function highlight() {
650 | 	document.body.classList.add("highlight");
651 | }
652 | 
653 | function unhighlight() {
654 | 	document.body.classList.remove("highlight");
655 | }
656 | 
657 | function preventdefault(e: Event) {
658 | 	e.preventDefault();
659 | 	e.stopPropagation();
660 | }
661 | 
662 | async function copyurl() {
663 | 	await navigator.clipboard.writeText(signalserver.href);
664 | 	// TODO toast message on success.
665 | }
666 | 
667 | function updateqr(url: string) {
668 | 	const qr = webwormhole.qrencode(url);
669 | 	if (url === "" || qr === null) {
670 | 		qrImg.src = "";
671 | 		qrImg.alt = "";
672 | 		qrImg.title = "";
673 | 	} else {
674 | 		qrImg.src = URL.createObjectURL(new Blob([qr]));
675 | 		qrImg.alt = url;
676 | 		qrImg.title = `${url} - double click to copy`;
677 | 	}
678 | }
679 | 
680 | function hashchange() {
681 | 	const newhash = location.hash.substring(1);
682 | 	if (newhash !== "" && newhash !== phraseInput.value) {
683 | 		console.log("hash changed dialling new code");
684 | 		phraseInput.value = newhash;
685 | 		codechange();
686 | 		connect();
687 | 	}
688 | }
689 | 
690 | function codechange() {
691 | 	if (phraseInput.value === "") {
692 | 		dialButton.value = "CREATE WORMHOLE";
693 | 	} else {
694 | 		dialButton.value = "JOIN WORMHOLE";
695 | 	}
696 | }
697 | 
698 | function autocompletehint() {
699 | 	const words = phraseInput.value.split("-");
700 | 	const prefix = words[words.length - 1];
701 | 	const hint = webwormhole.match(prefix);
702 | 	autocompleteBox.innerText = hint;
703 | }
704 | 
705 | function autocomplete(e: KeyboardEvent) {
706 | 	// TODO more stateful autocomplete, i.e. repeated tabs cycle through matches.
707 | 	if (e.keyCode === 9) {
708 | 		e.preventDefault(); // Prevent tabs from doing tab things.
709 | 		const words = phraseInput.value.split("-");
710 | 		const prefix = words[words.length - 1];
711 | 		const hint = webwormhole.match(prefix);
712 | 		if (hint === "") {
713 | 			return;
714 | 		}
715 | 		phraseInput.value += `${hint.substring(prefix.length)}-`;
716 | 		autocompleteBox.innerText = "";
717 | 	}
718 | }
719 | 
720 | function browserhacks() {
721 | 	// Detect for features we need for this to work.
722 | 	if (!window.WebSocket || !window.RTCPeerConnection || !window.WebAssembly) {
723 | 		hacks.browserunsupported = true;
724 | 		hacks.nosw = true;
725 | 		hacks.nowasm = true;
726 | 		console.log("quirks: browser not supported");
727 | 		console.log(
728 | 			"websocket:",
729 | 			!!window.WebSocket,
730 | 			"webrtc:",
731 | 			!!window.RTCPeerConnection,
732 | 			"wasm:",
733 | 			!!window.WebAssembly
734 | 		);
735 | 		return;
736 | 	}
737 | 
738 | 	// Polyfill for Safari WASM streaming.
739 | 	if (!WebAssembly.instantiateStreaming) {
740 | 		WebAssembly.instantiateStreaming = async (resp, importObject) => {
741 | 			const source = await (await resp).arrayBuffer();
742 | 			return await WebAssembly.instantiate(source, importObject);
743 | 		};
744 | 		console.log("quirks: using wasm streaming polyfill");
745 | 	}
746 | 
747 | 	// Safari cannot save files from service workers.
748 | 	if (
749 | 		/Safari/.test(navigator.userAgent) &&
750 | 		!(
751 | 			/Chrome/.test(navigator.userAgent) || /Chromium/.test(navigator.userAgent)
752 | 		)
753 | 	) {
754 | 		hacks.nosw = true;
755 | 		console.log("quirks: serviceworkers disabled on safari");
756 | 	}
757 | 
758 | 	if (!navigator.serviceWorker) {
759 | 		hacks.nosw = true;
760 | 		console.log("quirks: no serviceworkers");
761 | 	}
762 | 
763 | 	// Work around iOS Safari <= 12 not being able to download blob URLs.
764 | 	// This can die when iOS Safari usage is less than 1% on this table:
765 | 	// https://caniuse.com/usage-table
766 | 	hacks.noblob = false;
767 | 	if (
768 | 		/^Mozilla\/5.0 \(iPhone; CPU iPhone OS 12_[0-9]_[0-9] like Mac OS X\)/.test(
769 | 			navigator.userAgent
770 | 		)
771 | 	) {
772 | 		hacks.noblob = true;
773 | 		hacks.nosw = true;
774 | 		console.log("quirks: using ios12 dataurl hack");
775 | 	}
776 | 
777 | 	// Work around iOS trying to connect when the link is previewed.
778 | 	// You never saw this.
779 | 	if (
780 | 		/iPad|iPhone|iPod/.test(navigator.userAgent) &&
781 | 		![320, 375, 414, 768, 1_024].includes(window.innerWidth)
782 | 	) {
783 | 		hacks.noautoconnect = true;
784 | 		console.log("quirks: detected ios page preview");
785 | 	}
786 | 
787 | 	// Firefox does not support clipboard.read.
788 | 	if (!navigator.clipboard || !navigator.clipboard.read) {
789 | 		hacks.noclipboardapi = true;
790 | 		console.log("quirks: clipboard api not supported");
791 | 	}
792 | 
793 | 	// Are we in an extension?
794 | 	if (window.chrome && chrome.runtime) {
795 | 		hacks.ext = true;
796 | 		hacks.nosw = true;
797 | 		console.log("quirks: browser extension");
798 | 	}
799 | }
800 | 
801 | async function domready() {
802 | 	return new Promise((resolve) => {
803 | 		document.addEventListener("DOMContentLoaded", resolve);
804 | 	});
805 | }
806 | 
807 | async function swready() {
808 | 	if (!hacks.nosw) {
809 | 		// Remove old /_/ scoped service worker.
810 | 		const regs = await navigator.serviceWorker.getRegistrations();
811 | 		for (let i = 0; i < regs.length; i++) {
812 | 			if (regs[i].scope.endsWith("/_/")) {
813 | 				regs[i].unregister();
814 | 			}
815 | 		}
816 | 
817 | 		// The scope has to be "/" and not just "/_/" in order to meet Chrome's
818 | 		// PWA installability criteria.
819 | 		const reg = await navigator.serviceWorker.register("sw.js", { scope: "/" });
820 | 		serviceworker = reg.active || reg.waiting || reg.installing;
821 | 
822 | 		// Add a listener for Share Target API requests forwarded from service worker.
823 | 		// This doesn't seem to actually work, and it's quite difficult to debug. We
824 | 		// might remove it soon.
825 | 		navigator.serviceWorker.addEventListener("message", (e) => {
826 | 			const msg = e.data;
827 | 			const item = new Upload(
828 | 				{
829 | 					name: msg.name,
830 | 					type: msg.type,
831 | 					size: msg.size,
832 | 				},
833 | 				msg.stream
834 | 			);
835 | 			item.li.classList.add("pending");
836 | 			item.li.innerText = `${msg.name}`;
837 | 			transfersList.appendChild(item.li);
838 | 			send(item);
839 | 
840 | 			if (state === "disconnected") {
841 | 				connect();
842 | 			}
843 | 		});
844 | 
845 | 		if (serviceworker) {
846 | 			console.log("service worker registered:", serviceworker.state);
847 | 		}
848 | 	}
849 | }
850 | 
851 | async function wasmready(wasmURL: string) {
852 | 	if (!hacks.nowasm) {
853 | 		const go = new Go();
854 | 		const wasm = await WebAssembly.instantiateStreaming(
855 | 			fetch(wasmURL),
856 | 			go.importObject
857 | 		);
858 | 		go.run(wasm.instance);
859 | 	}
860 | }
861 | 
862 | async function init() {
863 | 	// Detect Browser Quirks.
864 | 	browserhacks();
865 | 
866 | 	let wasmURL = "webwormhole.wasm";
867 | 	if (hacks.ext) {
868 | 		signalserver = new URL("https://webwormhole.io/");
869 | 		wasmURL = chrome.runtime.getURL("webwormhole.wasm");
870 | 	}
871 | 
872 | 	// Wait for the ServiceWorker, WebAssembly, and DOM to be ready.
873 | 	await Promise.all([domready(), swready(), wasmready(wasmURL)]);
874 | 
875 | 	// Wireup HTML.
876 | 	filepicker = document.getElementById("filepicker") as HTMLInputElement;
877 | 	dialButton = document.getElementById("dial") as HTMLInputElement;
878 | 	phraseInput = document.getElementById("magiccode") as HTMLInputElement;
879 | 	clipboardInput = document.getElementById("clipboard") as HTMLInputElement;
880 | 	mainForm = document.getElementById("main") as HTMLFormElement;
881 | 	qrImg = document.getElementById("qr") as HTMLImageElement;
882 | 	transfersList = document.getElementById("transfers") as HTMLElement;
883 | 	infoBox = document.getElementById("info") as HTMLElement;
884 | 	autocompleteBox = document.getElementById("autocomplete") as HTMLElement;
885 | 
886 | 	// Friendly error message and bail out if things are clearely not going to work.
887 | 	if (hacks.browserunsupported) {
888 | 		infoBox.innerText =
889 | 			"Browser missing required feature. This application needs support for WebSockets, WebRTC, and WebAssembly.";
890 | 		document.body.classList.add("error");
891 | 		return;
892 | 	}
893 | 
894 | 	// Install event handlers. If we start to allow queueing files before
895 | 	// connections we might want to move these into domready so as to not
896 | 	// block them.
897 | 	window.addEventListener("hashchange", hashchange);
898 | 	phraseInput.addEventListener("input", codechange);
899 | 	phraseInput.addEventListener("keydown", autocomplete);
900 | 	phraseInput.addEventListener("input", autocompletehint);
901 | 	filepicker.addEventListener("change", pick);
902 | 	clipboardInput.addEventListener("click", pasteClipboard);
903 | 	mainForm.addEventListener("submit", preventdefault);
904 | 	mainForm.addEventListener("submit", connect);
905 | 	qrImg.addEventListener("dblclick", copyurl);
906 | 	document.body.addEventListener("drop", preventdefault);
907 | 	document.body.addEventListener("dragenter", preventdefault);
908 | 	document.body.addEventListener("dragover", preventdefault);
909 | 	document.body.addEventListener("drop", preventdefault);
910 | 	document.body.addEventListener("dragleave", preventdefault);
911 | 	document.body.addEventListener("drop", drop);
912 | 	document.body.addEventListener("dragenter", highlight);
913 | 	document.body.addEventListener("dragover", highlight);
914 | 	document.body.addEventListener("drop", unhighlight);
915 | 	document.body.addEventListener("dragleave", unhighlight);
916 | 
917 | 	if (location.hash.substring(1) !== "") {
918 | 		phraseInput.value = location.hash.substring(1);
919 | 	}
920 | 	codechange(); // User might have typed something while we were loading.
921 | 	dialButton.disabled = false;
922 | 
923 | 	if (!hacks.noautoconnect && phraseInput.value !== "") {
924 | 		connect();
925 | 	}
926 | }
927 | 
928 | init();
929 | 


--------------------------------------------------------------------------------
/web/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"manifest_version": 3,
 3 | 	"name": "WebWormhole",
 4 | 	"version": "0.8",
 5 | 	"description": "WebWormhole lets you send files from one place to another.",
 6 | 	"icons": {
 7 | 		"16": "icon.svg",
 8 | 		"48": "icon.svg",
 9 | 		"96": "icon.svg",
10 | 		"128": "icon.svg",
11 | 		"192": "icon.svg",
12 | 		"512": "icon.svg"
13 | 	},
14 | 	"action": {
15 | 		"default_title": "WebWormhole",
16 | 		"default_icon": "icon.svg"
17 | 	},
18 | 	"background": {
19 | 		"service_worker":  "sw.js",
20 | 		"scripts":  ["sw.js"]
21 | 	},
22 | 	"content_security_policy": {
23 | 		"extension_pages": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; img-src 'self' blob:; connect-src wss://webwormhole.io"
24 | 	},
25 | 	"browser_specific_settings": {
26 | 		"gecko": {
27 | 			"id": "{30b9cc0e-c7e0-4de7-81a1-71742f1d652d}"
28 | 		}
29 | 	},
30 | 	"minimum_chrome_version": "100"
31 | }


--------------------------------------------------------------------------------
/web/pwa.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "WebWormhole",
 3 | 	"icons": [
 4 | 		{
 5 | 			"src": "icon192.png",
 6 | 			"type": "image/png",
 7 | 			"sizes": "192x192"
 8 | 		},
 9 | 		{
10 | 			"src": "icon512.png",
11 | 			"type": "image/png",
12 | 			"sizes": "512x512"
13 | 		}
14 | 	],
15 | 	"start_url": "/",
16 | 	"display": "standalone",
17 | 	"scope": "/",
18 | 	"background_color": "#321d47",
19 | 	"theme_color": "#321d47",
20 | 	"description": "WebWormhole lets you send files from one place to another.",
21 | 	"screenshots": [],
22 | 	"share_target": {
23 | 		"action": "/_/",
24 | 		"method": "POST",
25 | 		"enctype": "multipart/form-data",
26 | 		"params": {
27 | 			"title": "title",
28 | 			"text": "text",
29 | 			"url": "url",
30 | 			"files": [
31 | 				{
32 | 					"name": "plaintext",
33 | 					"accept": ["text/plain", ".txt"]
34 | 				},
35 | 				{
36 | 					"name": "image",
37 | 					"accept": "image/png"
38 | 				}
39 | 			]
40 | 		}
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/web/style.css:
--------------------------------------------------------------------------------
  1 | :root {
  2 | 	--purple: #321d47;
  3 | 	--yellow: #ffa400;
  4 | 	--yellow-tint: #ffa40012;
  5 | 	--grey: #8e8a8a;
  6 | 	--grey-tint: #00000054;
  7 | 	--grey-light: #aeac9c;
  8 | 	--white: white;
  9 | 	--black: black;
 10 | 	--error: #8a504a;
 11 | 	--dialling: #8c782a;
 12 | 	--connected: #c1ffab;
 13 | 	--highlight: #8464a4;
 14 | 
 15 | 	/* Palette of background colours chosen by the session key. */
 16 | 	--palette-0: #c1ffab; /* bright green */
 17 | 	--palette-1: #c3c0a7; /* brown */
 18 | 	--palette-2: #b7ae5e; /* gold */
 19 | 	--palette-3: #6cc3c5; /* teal */
 20 | 	--palette-4: #cccccc; /* grey */
 21 | 	--palette-5: #88b6fb; /* blue */
 22 | 	--palette-6: #cdff33; /* lime */
 23 | 	--palette-7: #e796ea; /* purple */
 24 | }
 25 | 
 26 | html {
 27 | 	box-sizing: border-box;
 28 | 	margin: 0;
 29 | 	padding: 0;
 30 | }
 31 | 
 32 | body {
 33 | 	align-items: center;
 34 | 	background-image: url("space.svg");
 35 | 	background-color: var(--purple);
 36 | 	color: var(--white);
 37 | 	display: flex;
 38 | 	flex-direction: column;
 39 | 	font-size: 18px;
 40 | 	font-family: Arial, Helvetica, sans-serif;
 41 | 	justify-content: center;
 42 | 	height: 100vh;
 43 | 	margin: 0;
 44 | 	padding: 0;
 45 | 	box-shadow: inset 0 0 150px -50px var(--black);
 46 | 	transition: background-color 0.3s;
 47 | }
 48 | 
 49 | body.disconnected,
 50 | body.error {
 51 | 	background-color: var(--error);
 52 | }
 53 | 
 54 | body.dialling {
 55 | 	background-color: var(--dialling);
 56 | }
 57 | 
 58 | body.connected {
 59 | 	background-color: var(--connected);
 60 | }
 61 | 
 62 | #footer {
 63 | 	font-size: small;
 64 | 	text-align: left;
 65 | }
 66 | 
 67 | .connected #footer {
 68 | 	display: none;
 69 | }
 70 | 
 71 | #footer ul {
 72 | 	list-style: none;
 73 | 	margin: 0;
 74 | 	padding: 0;
 75 | }
 76 | 
 77 | #footer li {
 78 | 	margin: 4px 0;
 79 | }
 80 | 
 81 | #main {
 82 | 	display: flex;
 83 | 	align-items: center;
 84 | 	flex-flow: column;
 85 | 	justify-content: space-between;
 86 | 	padding: 1em 0;
 87 | 	overflow: auto;
 88 | 	text-align: center;
 89 | 	box-shadow: 0px 0px 75px 0px var(--grey-tint);
 90 | 	background: var(--purple);
 91 | 	border: 4px solid transparent;
 92 | 	box-sizing: border-box;
 93 | }
 94 | 
 95 | .connected #main {
 96 | 	justify-content: space-between;
 97 | 	transition: all 1s;
 98 | }
 99 | 
100 | .highlight #main {
101 | 	background-color: var(--highlight);
102 | 	border: 4px dashed var(--white);
103 | }
104 | 
105 | #prompt {
106 | 	display: flex;
107 | 	align-items: center;
108 | 	flex-flow: column;
109 | }
110 | 
111 | #prompt input {
112 | 	margin: 4px;
113 | }
114 | 
115 | .connected #prompt p,
116 | .dialling #prompt p {
117 | 	display: none;
118 | }
119 | 
120 | #info {
121 | 	margin: 16px 8px;
122 | 	font-size: 18px;
123 | 	padding: 8px 0;
124 | 	text-align: center;
125 | }
126 | 
127 | .connected #info {
128 | 	display: none;
129 | }
130 | 
131 | #top {
132 | 	display: none;
133 | }
134 | 
135 | .connected #top {
136 | 	display: unset;
137 | }
138 | 
139 | #filepicker {
140 | 	display: none;
141 | }
142 | 
143 | #filepicker-wrap {
144 | 	display: inline-block;
145 | }
146 | 
147 | #transfers {
148 | 	display: none;
149 | 	list-style-type: none;
150 | 	padding-left: 0;
151 | 	margin: 0;
152 | 	width: 80%;
153 | 	max-width: 400px;
154 | }
155 | 
156 | .connected #transfers,
157 | .dialling #transfers {
158 | 	display: unset;
159 | }
160 | 
161 | #transfers li {
162 | 	border-color: var(--grey);
163 | 	border-style: solid;
164 | 	border-width: 1px;
165 | 	border-radius: 4px;
166 | 	background-color: var(--grey-tint);
167 | 	margin: 5px;
168 | 	padding: 8px;
169 | 	box-shadow: 0px 0px 4px 0px var(--grey-tint);
170 | }
171 | 
172 | #transfers li.upload {
173 | 	list-style-type: "↑ ";
174 | }
175 | 
176 | #transfers li.download {
177 | 	list-style-type: "↓ ";
178 | }
179 | 
180 | #transfers li.pending {
181 | 	list-style-type: "... ";
182 | }
183 | 
184 | #qr {
185 | 	margin: 4px;
186 | 	border: 2px solid;
187 | 	width: 256px;
188 | 	height: 256px;
189 | 	display: none;
190 | }
191 | 
192 | .dialling #qr[src] {
193 | 	display: unset;
194 | }
195 | 
196 | #magiccode {
197 | 	color: var(--yellow);
198 | 	background: var(--yellow-tint);
199 | 	border: 2px solid var(--yellow);
200 | 	border-radius: 10px;
201 | 	font-weight: bold;
202 | 	margin: 4px;
203 | 	padding: 16px;
204 | 	text-align: center;
205 | 	text-transform: uppercase;
206 | }
207 | 
208 | .connected #magiccode {
209 | 	opacity: 0.2;
210 | }
211 | 
212 | .error #magiccode {
213 | 	display: none;
214 | }
215 | 
216 | #dial {
217 | 	text-transform: uppercase;
218 | }
219 | 
220 | .connected #dial,
221 | .error #dial {
222 | 	display: none;
223 | }
224 | 
225 | #autocomplete {
226 | 	height: 1em;
227 | 	opacity: 0.5;
228 | }
229 | 
230 | .connected #autocomplete,
231 | .dialling #autocomplete {
232 | 	display: none;
233 | }
234 | 
235 | .button {
236 | 	-webkit-appearance: none;
237 | 	appearance: none;
238 | 	background: var(--yellow);
239 | 	border-radius: 10px;
240 | 	border: none;
241 | 	box-shadow: 0px 0px 5px 0px var(--grey-tint);
242 | 	color: var(--purple);
243 | 	font-weight: bold;
244 | 	font-size: medium;
245 | 	cursor: pointer;
246 | 	margin: 8px 0px;
247 | 	padding: 16px;
248 | 	transition: all 0.2s ease 0s;
249 | }
250 | 
251 | .button:hover {
252 | 	box-shadow: 0px 0px 5px 0px var(--grey-tint);
253 | 	opacity: 0.75;
254 | }
255 | 
256 | .button:disabled,
257 | .button:disabled:hover {
258 | 	background: var(--grey);
259 | 	box-shadow: 0px 0px 5px 0px var(--grey-tint);
260 | 	color: var(--grey-light);
261 | 	cursor: unset;
262 | 	letter-spacing: unset;
263 | 	transition: all 0.2s ease 0s;
264 | }
265 | 
266 | a {
267 | 	text-decoration: none;
268 | 	color: var(--yellow);
269 | }
270 | 
271 | a:link,
272 | a:visited {
273 | 	border-bottom: 1px dotted;
274 | }
275 | 
276 | a:link:hover,
277 | a:visited:hover {
278 | 	border-bottom: 1px solid;
279 | }
280 | 
281 | 
282 | #main {
283 | 	height: min-content;
284 | 	min-height: 200px;
285 | 	width: 100%;
286 | }
287 | 
288 | @media only screen and (min-width: 700px) {
289 | 	#main {
290 | 		width: min-content;
291 | 		min-width: 400px;
292 | 		height: 100%;
293 | 	}
294 | 	#info {
295 | 		margin-top: 10vh;
296 | 	}
297 | }
298 | 


--------------------------------------------------------------------------------
/web/sw.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | /// <reference no-default-lib="true"/>
  3 | /// <reference lib="es2018" />
  4 | /// <reference lib="webworker" />
  5 | // Workaround to tell TypeScript about the correct type of a ServiceWorker.
  6 | const sw = self;
  7 | // There can be multiple clients (pages) receiving files, so they generate an id
  8 | // and here we store info assosiated with each transfer.
  9 | const streams = new Map();
 10 | class Stream {
 11 |     constructor(name, size, filetype) {
 12 |         this.offset = 0;
 13 |         this.name = name;
 14 |         this.size = size;
 15 |         this.filetype = filetype;
 16 |         this.stream = new ReadableStream(this);
 17 |     }
 18 |     start(controller) {
 19 |         this.controller = controller;
 20 |     }
 21 |     cancel(reason) {
 22 |         console.warn("stream cancelled", reason);
 23 |     }
 24 | }
 25 | function waitForMetadata(id) {
 26 |     return new Promise((resolve, reject) => {
 27 |         streams.set(id, { resolve, reject });
 28 |     });
 29 | }
 30 | function signalMetadataReady(id, s) {
 31 |     if (streams.has(id)) {
 32 |         streams.get(id).resolve(s);
 33 |     }
 34 | }
 35 | sw.addEventListener("message", (e) => {
 36 |     const msg = e.data;
 37 |     const id = msg.id;
 38 |     switch (msg.type) {
 39 |         case "metadata": {
 40 |             const s = new Stream(msg.name, msg.size, msg.filetype);
 41 |             // Resolve promise if GET request arrived first.
 42 |             signalMetadataReady(id, s);
 43 |             streams.set(id, s);
 44 |             return;
 45 |         }
 46 |         case "data": {
 47 |             const s = streams.get(id);
 48 |             if (msg.offset !== s.offset) {
 49 |                 console.warn(`aborting ${id}: got data out of order`);
 50 |                 // TODO abort fetch response
 51 |                 streams.delete(id);
 52 |                 return;
 53 |             }
 54 |             s.controller.enqueue(new Uint8Array(msg.data));
 55 |             s.offset += msg.data.byteLength;
 56 |             return;
 57 |         }
 58 |         case "end": {
 59 |             const s = streams.get(id);
 60 |             s.controller.close();
 61 |             // Synchronize with fetch handler to clean up properly.
 62 |             if (s.requestHandled) {
 63 |                 streams.delete(id);
 64 |             }
 65 |             else {
 66 |                 s.streamHandled = true;
 67 |             }
 68 |             return;
 69 |         }
 70 |         case "error": {
 71 |             streams.get(id).controller.error(msg.error);
 72 |             return;
 73 |         }
 74 |     }
 75 | });
 76 | function encodeFilename(filename) {
 77 |     return encodeURIComponent(filename)
 78 |         .replace(/'/g, "%27")
 79 |         .replace(/\(/g, "%28")
 80 |         .replace(/\(/g, "%29")
 81 |         .replace(/\*/g, "%2A");
 82 | }
 83 | async function streamDownload(id) {
 84 |     // Request may arrive before metadata.
 85 |     const s = streams.get(id) || (await waitForMetadata(id));
 86 |     // Synchronize with message handler end to clean up properly.
 87 |     if (s.streamHandled) {
 88 |         streams.delete(id);
 89 |     }
 90 |     else {
 91 |         s.requestHandled = true;
 92 |     }
 93 |     const { size, name, filetype, stream } = s;
 94 |     console.log(`downloading ${name} (${id})`);
 95 |     return new Response(stream, {
 96 |         headers: {
 97 |             "Content-Type": filetype,
 98 |             "Content-Length": size,
 99 |             "Content-Disposition": `attachment; filename*=UTF-8''${encodeFilename(name)}`,
100 |         },
101 |     });
102 | }
103 | async function streamUpload(e) {
104 |     const contentLength = e.request.headers.get("content-length");
105 |     const contentType = e.request.headers.get("content-type");
106 |     const form = await e.request.formData();
107 |     const title = form.get("title");
108 |     if (!title) {
109 |         e.respondWith(new Response("no title", { status: 500 }));
110 |         return;
111 |     }
112 |     let body;
113 |     if (e.request.body) {
114 |         body = e.request.body;
115 |     }
116 |     else {
117 |         e.respondWith(new Response("no body", { status: 500 }));
118 |         return;
119 |     }
120 |     console.log(`uploading ${title}`);
121 |     e.respondWith(Response.redirect("/", 303)); // get index.html?
122 |     const client = await sw.clients.get(e.clientId || e.resultingClientId);
123 |     if (!client) {
124 |         e.respondWith(new Response("no client", { status: 500 }));
125 |         return;
126 |     }
127 |     // ReadableStream is transferable on Chrome at the time of writing. Since Share
128 |     // Target also only works on Chome, we can use this and avoid the complexity of
129 |     // chunking over postMessage (like we do with downloads) or having to read the
130 |     // whole file into memory.
131 |     // TypeScript doesn't know that ReadableStream is transferable, hence body as
132 |     // any.
133 |     client.postMessage({
134 |         name: title,
135 |         size: contentLength,
136 |         type: contentType,
137 |         stream: body,
138 |     }, [body]);
139 | }
140 | sw.addEventListener("fetch", (e) => {
141 |     const PREFIX = "/_";
142 |     const url = new URL(e.request.url);
143 |     // Stream download from WebRTC DataChannel.
144 |     if (url.pathname.startsWith(`${PREFIX}/`) && e.request.method === "GET") {
145 |         const id = url.pathname.substring(`${PREFIX}/`.length);
146 |         e.respondWith(streamDownload(id));
147 |         return;
148 |     }
149 |     // Stream upload to WebRTC DataChannel, triggered by Share Target API.
150 |     if (url.pathname.startsWith(`${PREFIX}/`) && e.request.method === "POST") {
151 |         streamUpload(e);
152 |         return;
153 |     }
154 |     // Default to passthrough.
155 |     e.respondWith(fetch(e.request));
156 | });
157 | 
158 | if (chrome && chrome.runtime) {
159 |     chrome.action.onClicked.addListener(() => {
160 |         chrome.windows.create({
161 |             type: "panel",
162 |             url: chrome.runtime.getURL("index.html"),
163 |             width: 600,
164 |             height: 600,
165 |         });
166 |     });
167 | }
168 | 


--------------------------------------------------------------------------------
/web/sw.ts:
--------------------------------------------------------------------------------
  1 | /// <reference no-default-lib="true"/>
  2 | /// <reference lib="es2018" />
  3 | /// <reference lib="webworker" />
  4 | 
  5 | // Workaround to tell TypeScript about the correct type of a ServiceWorker.
  6 | const sw = self as ServiceWorkerGlobalScope & typeof globalThis;
  7 | 
  8 | // There can be multiple clients (pages) receiving files, so they generate an id
  9 | // and here we store info assosiated with each transfer.
 10 | const streams = new Map();
 11 | 
 12 | class Stream {
 13 | 	name: string;
 14 | 	size: number;
 15 | 	filetype: string;
 16 | 	offset = 0;
 17 | 	controller?: ReadableStreamDefaultController;
 18 | 	stream: ReadableStream;
 19 | 
 20 | 	constructor(name: string, size: number, filetype: string) {
 21 | 		this.name = name;
 22 | 		this.size = size;
 23 | 		this.filetype = filetype;
 24 | 		this.stream = new ReadableStream(this);
 25 | 	}
 26 | 
 27 | 	start(controller: ReadableStreamDefaultController) {
 28 | 		this.controller = controller;
 29 | 	}
 30 | 
 31 | 	cancel(reason: string) {
 32 | 		console.warn("stream cancelled", reason);
 33 | 	}
 34 | }
 35 | 
 36 | function waitForMetadata(id: string) {
 37 | 	return new Promise((resolve, reject) => {
 38 | 		streams.set(id, { resolve, reject });
 39 | 	});
 40 | }
 41 | 
 42 | function signalMetadataReady(id: string, s: Stream) {
 43 | 	if (streams.has(id)) {
 44 | 		streams.get(id).resolve(s);
 45 | 	}
 46 | }
 47 | 
 48 | sw.addEventListener("message", (e) => {
 49 | 	const msg = e.data;
 50 | 	const id = msg.id;
 51 | 
 52 | 	switch (msg.type) {
 53 | 		case "metadata": {
 54 | 			const s = new Stream(msg.name, msg.size, msg.filetype);
 55 | 
 56 | 			// Resolve promise if GET request arrived first.
 57 | 			signalMetadataReady(id, s);
 58 | 
 59 | 			streams.set(id, s);
 60 | 			return;
 61 | 		}
 62 | 		case "data": {
 63 | 			const s = streams.get(id);
 64 | 
 65 | 			if (msg.offset !== s.offset) {
 66 | 				console.warn(`aborting ${id}: got data out of order`);
 67 | 				// TODO abort fetch response
 68 | 				streams.delete(id);
 69 | 				return;
 70 | 			}
 71 | 			s.controller.enqueue(new Uint8Array(msg.data));
 72 | 			s.offset += msg.data.byteLength;
 73 | 
 74 | 			return;
 75 | 		}
 76 | 		case "end": {
 77 | 			const s = streams.get(id);
 78 | 
 79 | 			s.controller.close();
 80 | 
 81 | 			// Synchronize with fetch handler to clean up properly.
 82 | 			if (s.requestHandled) {
 83 | 				streams.delete(id);
 84 | 			} else {
 85 | 				s.streamHandled = true;
 86 | 			}
 87 | 
 88 | 			return;
 89 | 		}
 90 | 		case "error": {
 91 | 			streams.get(id).controller.error(msg.error);
 92 | 			return;
 93 | 		}
 94 | 	}
 95 | });
 96 | 
 97 | function encodeFilename(filename: string) {
 98 | 	return encodeURIComponent(filename)
 99 | 		.replace(/'/g, "%27")
100 | 		.replace(/\(/g, "%28")
101 | 		.replace(/\(/g, "%29")
102 | 		.replace(/\*/g, "%2A");
103 | }
104 | 
105 | async function streamDownload(id: string) {
106 | 	// Request may arrive before metadata.
107 | 	const s = streams.get(id) || (await waitForMetadata(id));
108 | 
109 | 	// Synchronize with message handler end to clean up properly.
110 | 	if (s.streamHandled) {
111 | 		streams.delete(id);
112 | 	} else {
113 | 		s.requestHandled = true;
114 | 	}
115 | 
116 | 	const { size, name, filetype, stream } = s;
117 | 
118 | 	console.log(`downloading ${name} (${id})`);
119 | 
120 | 	return new Response(stream, {
121 | 		headers: {
122 | 			"Content-Type": filetype,
123 | 			"Content-Length": size,
124 | 			"Content-Disposition": `attachment; filename*=UTF-8''${encodeFilename(
125 | 				name
126 | 			)}`,
127 | 		},
128 | 	});
129 | }
130 | 
131 | async function streamUpload(e: FetchEvent) {
132 | 	const contentLength = e.request.headers.get("content-length");
133 | 	const contentType = e.request.headers.get("content-type");
134 | 	const form = await e.request.formData();
135 | 	const title = form.get("title");
136 | 
137 | 	if (!title) {
138 | 		e.respondWith(new Response("no title", { status: 500 }));
139 | 		return
140 | 	}
141 | 
142 | 	let body: ReadableStream<Uint8Array>;
143 | 	if (e.request.body) {
144 | 		body = e.request.body;
145 | 	} else {
146 | 		e.respondWith(new Response("no body", { status: 500 }));
147 | 		return
148 | 	}
149 | 
150 | 	console.log(`uploading ${title}`);
151 | 
152 | 	e.respondWith(Response.redirect("/", 303)); // get index.html?
153 | 
154 | 	const client = await sw.clients.get(e.clientId || e.resultingClientId);
155 | 	if (!client) {
156 | 		e.respondWith(new Response("no client", { status: 500 }));
157 | 		return
158 | 	}
159 | 
160 | 	// ReadableStream is transferable on Chrome at the time of writing. Since Share
161 | 	// Target also only works on Chome, we can use this and avoid the complexity of
162 | 	// chunking over postMessage (like we do with downloads) or having to read the
163 | 	// whole file into memory.
164 | 	// TypeScript doesn't know that ReadableStream is transferable, hence body as
165 | 	// any.
166 | 	client.postMessage(
167 | 		{
168 | 			name: title,
169 | 			size: contentLength,
170 | 			type: contentType,
171 | 			stream: body,
172 | 		},
173 | 		[body as any]
174 | 	);
175 | }
176 | 
177 | sw.addEventListener("fetch", (e) => {
178 | 	const PREFIX = "/_";
179 | 	const url = new URL(e.request.url);
180 | 
181 | 	// Stream download from WebRTC DataChannel.
182 | 	if (url.pathname.startsWith(`${PREFIX}/`) && e.request.method === "GET") {
183 | 		const id = url.pathname.substring(`${PREFIX}/`.length);
184 | 		e.respondWith(streamDownload(id));
185 | 		return;
186 | 	}
187 | 
188 | 	// Stream upload to WebRTC DataChannel, triggered by Share Target API.
189 | 	if (url.pathname.startsWith(`${PREFIX}/`) && e.request.method === "POST") {
190 | 		streamUpload(e);
191 | 		return;
192 | 	}
193 | 
194 | 	// Default to passthrough.
195 | 	e.respondWith(fetch(e.request));
196 | });
197 | 
198 | if (chrome && chrome.runtime) {
199 | 	chrome.action.onClicked.addListener(() => {
200 | 		chrome.windows.create({
201 | 			type: "panel",
202 | 			url: chrome.runtime.getURL("index.html"),
203 | 			width: 600,
204 | 			height: 600,
205 | 		});
206 | 	});
207 | }


--------------------------------------------------------------------------------
/web/webwormhole.go:
--------------------------------------------------------------------------------
  1 | // +build js,wasm
  2 | 
  3 | // WebAssembly program webwormhole is a set of wrappers for webwormhole and
  4 | // related packages in order to run in browser.
  5 | //
  6 | // All functions are added to the webwormhole global object.
  7 | package main
  8 | 
  9 | import (
 10 | 	"crypto/rand"
 11 | 	"crypto/sha256"
 12 | 	"encoding/base64"
 13 | 	"io"
 14 | 	"strconv"
 15 | 	"syscall/js"
 16 | 
 17 | 	"filippo.io/cpace"
 18 | 	"golang.org/x/crypto/hkdf"
 19 | 	"golang.org/x/crypto/nacl/secretbox"
 20 | 	"rsc.io/qr"
 21 | 	"webwormhole.io/wordlist"
 22 | )
 23 | 
 24 | // state is the PAKE state so far.
 25 | //
 26 | // We can't pass Go pointers to JavaScript, but we need to keep
 27 | // the PAKE state (at least for the A side) between invocations.
 28 | // We keep it as a single instance variable here, which means an
 29 | // instance of this program can only do one A handshake at a time.
 30 | // If more is needed this can be changed into a map[something]*cpace.State.
 31 | var state *cpace.State
 32 | 
 33 | // start(pass string) (base64msgA string)
 34 | func start(_ js.Value, args []js.Value) interface{} {
 35 | 	pass := make([]byte, args[0].Length())
 36 | 	js.CopyBytesToGo(pass, args[0])
 37 | 
 38 | 	msgA, s, err := cpace.Start(string(pass), cpace.NewContextInfo("", "", nil))
 39 | 	if err != nil {
 40 | 		return nil
 41 | 	}
 42 | 	state = s
 43 | 
 44 | 	return base64.URLEncoding.EncodeToString(msgA)
 45 | }
 46 | 
 47 | // finish(base64msgB string) (key []byte)
 48 | func finish(_ js.Value, args []js.Value) interface{} {
 49 | 	msgB, err := base64.URLEncoding.DecodeString(args[0].String())
 50 | 	if err != nil {
 51 | 		return nil
 52 | 	}
 53 | 
 54 | 	mk, err := state.Finish(msgB)
 55 | 	if err != nil {
 56 | 		return nil
 57 | 	}
 58 | 	hkdf := hkdf.New(sha256.New, mk, nil, nil)
 59 | 	key := [32]byte{}
 60 | 	_, err = io.ReadFull(hkdf, key[:])
 61 | 	if err != nil {
 62 | 		return nil
 63 | 	}
 64 | 
 65 | 	dst := js.Global().Get("Uint8Array").New(32)
 66 | 	js.CopyBytesToJS(dst, key[:])
 67 | 
 68 | 	return dst
 69 | }
 70 | 
 71 | // exchange(pass, base64msgA string) (key []byte, base64msgB string)
 72 | func exchange(_ js.Value, args []js.Value) interface{} {
 73 | 	pass := make([]byte, args[0].Length())
 74 | 	js.CopyBytesToGo(pass, args[0])
 75 | 	msgA, err := base64.URLEncoding.DecodeString(args[1].String())
 76 | 	if err != nil {
 77 | 		return []interface{}{nil, nil}
 78 | 	}
 79 | 
 80 | 	msgB, mk, err := cpace.Exchange(string(pass), cpace.NewContextInfo("", "", nil), msgA)
 81 | 	if err != nil {
 82 | 		return []interface{}{nil, nil}
 83 | 	}
 84 | 	hkdf := hkdf.New(sha256.New, mk, nil, nil)
 85 | 	key := [32]byte{}
 86 | 	_, err = io.ReadFull(hkdf, key[:])
 87 | 	if err != nil {
 88 | 		return []interface{}{nil, nil}
 89 | 	}
 90 | 
 91 | 	dst := js.Global().Get("Uint8Array").New(32)
 92 | 	js.CopyBytesToJS(dst, key[:])
 93 | 	return []interface{}{
 94 | 		dst,
 95 | 		base64.URLEncoding.EncodeToString(msgB),
 96 | 	}
 97 | }
 98 | 
 99 | // open(key []byte, base64ciphertext string) (cleartext string)
100 | func open(_ js.Value, args []js.Value) interface{} {
101 | 	var key [32]byte
102 | 	js.CopyBytesToGo(key[:], args[0])
103 | 	encrypted, err := base64.URLEncoding.DecodeString(args[1].String())
104 | 	if err != nil {
105 | 		return nil
106 | 	}
107 | 
108 | 	var nonce [24]byte
109 | 	copy(nonce[:], encrypted[:24])
110 | 	clear, ok := secretbox.Open(nil, encrypted[24:], &nonce, &key)
111 | 	if !ok {
112 | 		return nil
113 | 	}
114 | 
115 | 	return string(clear)
116 | }
117 | 
118 | // seal(key []byte, cleartext string) (base64ciphertext string)
119 | func seal(_ js.Value, args []js.Value) interface{} {
120 | 	var key [32]byte
121 | 	js.CopyBytesToGo(key[:], args[0])
122 | 	clear := args[1].String()
123 | 
124 | 	var nonce [24]byte
125 | 	if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
126 | 		return nil
127 | 	}
128 | 
129 | 	result := secretbox.Seal(nonce[:], []byte(clear), &nonce, &key)
130 | 
131 | 	return base64.URLEncoding.EncodeToString(result)
132 | }
133 | 
134 | // qrencode(url string) (png []byte)
135 | func qrencode(_ js.Value, args []js.Value) interface{} {
136 | 	code, err := qr.Encode(args[0].String(), qr.L)
137 | 	if err != nil {
138 | 		return nil
139 | 	}
140 | 	png := code.PNG()
141 | 	dst := js.Global().Get("Uint8Array").New(len(png))
142 | 	js.CopyBytesToJS(dst, png)
143 | 	return dst
144 | }
145 | 
146 | // encode(int, uint8array) (string)
147 | func encode(_ js.Value, args []js.Value) interface{} {
148 | 	slot := args[0].Int()
149 | 	pass := make([]byte, args[1].Length())
150 | 	js.CopyBytesToGo(pass, args[1])
151 | 	return wordlist.Encode(slot, pass)
152 | }
153 | 
154 | // decode(string) (int, uint8array)
155 | func decode(_ js.Value, args []js.Value) interface{} {
156 | 	code := args[0].String()
157 | 	slot, pass := wordlist.Decode(code)
158 | 	dst := js.Global().Get("Uint8Array").New(len(pass))
159 | 	js.CopyBytesToJS(dst, pass)
160 | 	return []interface{}{
161 | 		strconv.Itoa(slot),
162 | 		dst,
163 | 	}
164 | }
165 | 
166 | // match(string) (string)
167 | func match(_ js.Value, args []js.Value) interface{} {
168 | 	return wordlist.Match(args[0].String())
169 | }
170 | 
171 | // fingerprint(key []byte) (fp uint8array)
172 | func fingerprint(_ js.Value, args []js.Value) interface{} {
173 | 	key := make([]byte, 32)
174 | 	js.CopyBytesToGo(key, args[0])
175 | 	hkdf := hkdf.New(sha256.New, key, nil, []byte("fingerprint"))
176 | 	fp := make([]byte, 8)
177 | 	if _, err := io.ReadFull(hkdf, fp); err != nil {
178 | 		return nil
179 | 	}
180 | 	dst := js.Global().Get("Uint8Array").New(len(fp))
181 | 	js.CopyBytesToJS(dst, fp)
182 | 	return dst
183 | }
184 | 
185 | func main() {
186 | 	js.Global().Set("webwormhole", map[string]interface{}{
187 | 		"start":       js.FuncOf(start),
188 | 		"finish":      js.FuncOf(finish),
189 | 		"exchange":    js.FuncOf(exchange),
190 | 		"open":        js.FuncOf(open),
191 | 		"seal":        js.FuncOf(seal),
192 | 		"qrencode":    js.FuncOf(qrencode),
193 | 		"encode":      js.FuncOf(encode),
194 | 		"decode":      js.FuncOf(decode),
195 | 		"match":       js.FuncOf(match),
196 | 		"fingerprint": js.FuncOf(fingerprint),
197 | 	})
198 | 
199 | 	// Go wasm executables must remain running. Block indefinitely.
200 | 	select {}
201 | }
202 | 


--------------------------------------------------------------------------------
/web/ww.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | /// <reference lib="es2018" />
  3 | /// <reference lib="dom" />
  4 | // Error codes from webwormhole/dial.go.
  5 | var WormholeErrorCodes;
  6 | (function (WormholeErrorCodes) {
  7 |     WormholeErrorCodes[WormholeErrorCodes["closeNoSuchSlot"] = 4000] = "closeNoSuchSlot";
  8 |     WormholeErrorCodes[WormholeErrorCodes["closeSlotTimedOut"] = 4001] = "closeSlotTimedOut";
  9 |     WormholeErrorCodes[WormholeErrorCodes["closeNoMoreSlots"] = 4002] = "closeNoMoreSlots";
 10 |     WormholeErrorCodes[WormholeErrorCodes["closeWrongProto"] = 4003] = "closeWrongProto";
 11 |     WormholeErrorCodes[WormholeErrorCodes["closePeerHungUp"] = 4004] = "closePeerHungUp";
 12 |     WormholeErrorCodes[WormholeErrorCodes["closeBadKey"] = 4005] = "closeBadKey";
 13 |     WormholeErrorCodes[WormholeErrorCodes["closeWebRTCSuccess"] = 4006] = "closeWebRTCSuccess";
 14 |     WormholeErrorCodes[WormholeErrorCodes["closeWebRTCSuccessDirect"] = 4007] = "closeWebRTCSuccessDirect";
 15 |     WormholeErrorCodes[WormholeErrorCodes["closeWebRTCSuccessRelay"] = 4008] = "closeWebRTCSuccessRelay";
 16 |     WormholeErrorCodes[WormholeErrorCodes["closeWebRTCFailed"] = 4009] = "closeWebRTCFailed";
 17 | })(WormholeErrorCodes || (WormholeErrorCodes = {}));
 18 | class Wormhole {
 19 |     constructor(signalserver, code) {
 20 |         this.signalserver = signalserver;
 21 |         this.callback = () => { };
 22 |         if (code !== "") {
 23 |             [this.slot, this.pass] = webwormhole.decode(code);
 24 |             if (this.pass.length === 0) {
 25 |                 throw "bad code";
 26 |             }
 27 |             console.log("dialling slot:", this.slot);
 28 |             this.state = this.statePlayer2;
 29 |         }
 30 |         else {
 31 |             this.pass = crypto.getRandomValues(new Uint8Array(2));
 32 |             console.log("requesting slot");
 33 |             this.state = this.statePlayer1;
 34 |         }
 35 |         // There are 3 events that we need to synchronise with the caller on:
 36 |         //   1. we got the first message from the signalling server.
 37 |         //        We now have the slot number and the ICE server details, so we can
 38 |         //        create the wormhole code and PeerConnection object, and pass them back
 39 |         //        to the caller to display and configure, respectively.
 40 |         //   2. the caller is done configuring the PeerConnection.
 41 |         //        We can now create the offer or answer and send it to the peer.
 42 |         //   3. we've successfully authenticated the other peer.
 43 |         //        Signalling is now done, apart from trickling candidates. The caller
 44 |         //        can display the key fingerprint.
 45 |         this.done = new Promise((resolve, reject) => {
 46 |             this.resolve = resolve;
 47 |             this.reject = reject;
 48 |         });
 49 |     }
 50 |     async statePlayer1(data) {
 51 |         const msg = JSON.parse(data);
 52 |         console.log("assigned slot:", msg.slot);
 53 |         this.slot = parseInt(msg.slot, 10);
 54 |         if (!Number.isSafeInteger(this.slot)) {
 55 |             return this.fail("invalid slot");
 56 |         }
 57 |         this.pc = this.makePeerConnection(msg.iceServers);
 58 |         this.callback(this.pc, webwormhole.encode(this.slot, this.pass));
 59 |         return this.stateWaitForPAKEA;
 60 |     }
 61 |     async statePlayer2(data) {
 62 |         if (!this.ws) {
 63 |             return this.fail("panic");
 64 |         }
 65 |         const msg = JSON.parse(data);
 66 |         this.pc = this.makePeerConnection(msg.iceServers);
 67 |         this.callback(this.pc);
 68 |         const msgA = webwormhole.start(this.pass);
 69 |         if (!msgA) {
 70 |             return this.fail("could nnt generate A's PAKE message");
 71 |         }
 72 |         console.log("message a:", msgA);
 73 |         this.ws.send(msgA);
 74 |         return this.stateWaitForPAKEB;
 75 |     }
 76 |     async stateWaitForPAKEA(data) {
 77 |         if (!this.ws || !this.pc) {
 78 |             return this.fail("panic");
 79 |         }
 80 |         console.log("got pake message a:", data);
 81 |         let msgB;
 82 |         [this.key, msgB] = webwormhole.exchange(this.pass, data);
 83 |         console.log("message b:", msgB);
 84 |         if (!this.key) {
 85 |             return this.fail("could not generate key");
 86 |         }
 87 |         if (!msgB) {
 88 |             return this.fail("could not generate B's PAKE message");
 89 |         }
 90 |         console.log("generated key");
 91 |         this.ws.send(msgB);
 92 |         this.state = this.stateWaitForLocalOffer;
 93 |         const offer = await this.pc.createOffer();
 94 |         console.log("created offer");
 95 |         this.ws.send(webwormhole.seal(this.key, JSON.stringify(offer)));
 96 |         this.pc.setLocalDescription(offer);
 97 |         return this.stateWaitForRemoteAnswer;
 98 |     }
 99 |     async stateWaitForPAKEB(data) {
100 |         console.log("got pake message b:", data);
101 |         this.key = webwormhole.finish(data);
102 |         if (!this.key) {
103 |             return this.fail("could not generate key");
104 |         }
105 |         console.log("generated key");
106 |         return this.stateWaitForRemoteOffer;
107 |     }
108 |     async stateWaitForRemoteOffer(data) {
109 |         if (!this.ws || !this.key || !this.pc || !this.resolve) {
110 |             return this.fail("panic");
111 |         }
112 |         const msg = JSON.parse(webwormhole.open(this.key, data));
113 |         if (!msg) {
114 |             this.ws.send(webwormhole.seal(this.key, "bye"));
115 |             this.ws.close(WormholeErrorCodes.closeBadKey);
116 |             return this.fail("bad key");
117 |         }
118 |         if (msg.type !== "offer") {
119 |             return this.fail("unexpected message: ${msg}");
120 |         }
121 |         console.log("got offer");
122 |         this.state = this.stateWaitForLocalAnswer;
123 |         await this.pc.setRemoteDescription(new RTCSessionDescription(msg));
124 |         const answer = await this.pc.createAnswer();
125 |         console.log("created answer");
126 |         this.ws.send(webwormhole.seal(this.key, JSON.stringify(answer)));
127 |         this.resolve(webwormhole.fingerprint(this.key));
128 |         this.pc.setLocalDescription(answer);
129 |         return this.stateWaitForCandidates;
130 |     }
131 |     async stateWaitForRemoteAnswer(data) {
132 |         if (!this.ws || !this.key || !this.pc || !this.resolve) {
133 |             return this.fail("panic");
134 |         }
135 |         const msg = JSON.parse(webwormhole.open(this.key, data));
136 |         if (!msg) {
137 |             this.ws.send(webwormhole.seal(this.key, "bye"));
138 |             this.ws.close(WormholeErrorCodes.closeBadKey);
139 |             return this.fail("bad key");
140 |         }
141 |         if (msg.type !== "answer") {
142 |             return this.fail("unexpected message: ${msg}");
143 |         }
144 |         console.log("got answer");
145 |         this.pc.setRemoteDescription(new RTCSessionDescription(msg));
146 |         this.resolve(webwormhole.fingerprint(this.key));
147 |         return this.stateWaitForCandidates;
148 |     }
149 |     async stateWaitForCandidates(data) {
150 |         if (!this.key || !this.pc) {
151 |             return this.fail("panic");
152 |         }
153 |         this.processCandidate(data);
154 |         return this.stateWaitForCandidates;
155 |     }
156 |     async stateWaitForLocalOffer(data) {
157 |         return this.fail(`unexpected message: ${data}`);
158 |     }
159 |     async stateWaitForLocalAnswer(data) {
160 |         // In this state we already got an offer and the WebRTC API is busy
161 |         // making an answer. It's possible to get remote candidates from eager
162 |         // peers now, but it's not safe to add them to this.pc on all browsers
163 |         // just yet.
164 |         // Delay processing the candidate until the handshake is done.
165 |         // This "state" is special. It doesn't progress the state machine. The
166 |         // stateWaitForRemoteOffer body moves us into and out of this state.
167 |         await this.done;
168 |         this.processCandidate(data);
169 |         return this.state;
170 |     }
171 |     async stateError(data) {
172 |         return this.stateError;
173 |     }
174 |     async close() {
175 |         if (!this.ws || !this.pc) {
176 |             return;
177 |         }
178 |         switch (this.pc.iceConnectionState) {
179 |             case "connected": {
180 |                 const connType = await this.connType();
181 |                 // TODO UI to warn if relay is used.
182 |                 console.log("webrtc connected:", connType);
183 |                 switch (connType) {
184 |                     case "host":
185 |                     case "srflx":
186 |                     case "prflx": {
187 |                         this.ws.close(WormholeErrorCodes.closeWebRTCSuccessDirect);
188 |                         break;
189 |                     }
190 |                     case "relay": {
191 |                         this.ws.close(WormholeErrorCodes.closeWebRTCSuccessRelay);
192 |                         break;
193 |                     }
194 |                     default: {
195 |                         this.ws.close(WormholeErrorCodes.closeWebRTCSuccess);
196 |                         break;
197 |                     }
198 |                 }
199 |                 break;
200 |             }
201 |             case "failed": {
202 |                 this.ws.close(WormholeErrorCodes.closeWebRTCFailed);
203 |                 break;
204 |             }
205 |         }
206 |     }
207 |     processCandidate(data) {
208 |         if (!this.ws || !this.key || !this.pc) {
209 |             return;
210 |         }
211 |         const msg = JSON.parse(webwormhole.open(this.key, data));
212 |         if (!msg) {
213 |             this.fail("bad key");
214 |             this.ws.send(webwormhole.seal(this.key, "bye"));
215 |             this.ws.close(WormholeErrorCodes.closeBadKey);
216 |             return;
217 |         }
218 |         console.log("got remote candidate", msg.candidate);
219 |         this.pc.addIceCandidate(new RTCIceCandidate(msg));
220 |         return;
221 |     }
222 |     makePeerConnection(iceServers) {
223 |         const pc = new RTCPeerConnection({ iceServers: iceServers });
224 |         pc.onicecandidate = (e) => {
225 |             if (!this.ws || !this.key || !this.pc) {
226 |                 return;
227 |             }
228 |             if (e.candidate && e.candidate.candidate !== "") {
229 |                 console.log("got local candidate", e.candidate.candidate);
230 |                 this.ws.send(webwormhole.seal(this.key, JSON.stringify(e.candidate)));
231 |             }
232 |         };
233 |         return pc;
234 |     }
235 |     async connType() {
236 |         if (!this.pc) {
237 |             return "";
238 |         }
239 |         // RTCStatsReport.forEach is all that's defined in the TypeScript DOM defs, which
240 |         // makes this kind of awkward. Ah well.
241 |         const stats = await this.pc.getStats();
242 |         let id;
243 |         stats.forEach((s) => {
244 |             // s.selected gives more confidenece than s.state == "succeeded", but Chrome does
245 |             // not implement it.
246 |             if (s.type === "candidate-pair" &&
247 |                 s.state === "succeeded") {
248 |                 id = s.localCandidateId;
249 |             }
250 |         });
251 |         if (!id) {
252 |             return "";
253 |         }
254 |         let conntype = "";
255 |         stats.forEach((s) => {
256 |             if (s.id === id) {
257 |                 conntype = s.candidateType;
258 |             }
259 |         });
260 |         return conntype;
261 |     }
262 |     async dial() {
263 |         this.ws = new WebSocket(Wormhole.wsserver(this.signalserver, this.slot), Wormhole.protocol);
264 |         // Use lambdas so that 'this' in the respective bodies refers to the Wormhole
265 |         // instance, and not the WebSocket one.
266 |         this.ws.onopen = () => this.onopen();
267 |         this.ws.onerror = (e) => this.onerror(e);
268 |         this.ws.onclose = (e) => this.onclose(e);
269 |         this.ws.onmessage = (e) => this.onmessage(e);
270 |         return this.done;
271 |     }
272 |     async onmessage(m) {
273 |         if (!this.ws) {
274 |             return;
275 |         }
276 |         // Feed the state machine a new message.
277 |         this.state = await this.state(m.data);
278 |     }
279 |     onopen() {
280 |         console.log("websocket session established");
281 |     }
282 |     onerror(e) {
283 |         console.log("websocket session error:", e);
284 |         this.fail("could not connect to signalling server");
285 |     }
286 |     onclose(e) {
287 |         switch (e.code) {
288 |             case WormholeErrorCodes.closePeerHungUp:
289 |             case 1000:
290 |             case 1001: {
291 |                 // Normal closure of WebSocket.
292 |                 return;
293 |             }
294 |             case WormholeErrorCodes.closeNoSuchSlot: {
295 |                 this.fail("no such slot");
296 |                 return;
297 |             }
298 |             case WormholeErrorCodes.closeSlotTimedOut: {
299 |                 this.fail("timed out");
300 |                 return;
301 |             }
302 |             case WormholeErrorCodes.closeNoMoreSlots: {
303 |                 this.fail("could not get slot");
304 |                 return;
305 |             }
306 |             case WormholeErrorCodes.closeWrongProto: {
307 |                 this.fail("wrong protocol version: must update");
308 |                 return;
309 |             }
310 |             default: {
311 |                 this.fail(`websocket session closed: ${e.reason} (${e.code})`);
312 |                 return;
313 |             }
314 |         }
315 |     }
316 |     fail(reason) {
317 |         if (this.reject)
318 |             this.reject(reason);
319 |         return this.stateError;
320 |     }
321 |     // wsserver creates a WebSocket scheme (ws: or wss:) URL from an HTTP one.
322 |     static wsserver(url, slot) {
323 |         const u = new URL(url);
324 |         let protocol = "wss:";
325 |         if (u.protocol === "http:") {
326 |             protocol = "ws:";
327 |         }
328 |         let path = u.pathname;
329 |         if (!path.startsWith("/")) {
330 |             path = `/${path}`;
331 |         }
332 |         if (slot) {
333 |             path = `${path}${slot}`;
334 |         }
335 |         return `${protocol}//${u.host}${path}`;
336 |     }
337 |     // WASM loads the WebAssembly part from url.
338 |     static async WASM(url) {
339 |         // Polyfill for Safari WASM streaming.
340 |         if (!WebAssembly.instantiateStreaming) {
341 |             WebAssembly.instantiateStreaming = async (resp, importObject) => {
342 |                 const source = await (await resp).arrayBuffer();
343 |                 return await WebAssembly.instantiate(source, importObject);
344 |             };
345 |         }
346 |         const go = new Go();
347 |         const wasm = await WebAssembly.instantiateStreaming(fetch(url), go.importObject);
348 |         go.run(wasm.instance);
349 |     }
350 | }
351 | // Signalling protocol version.
352 | Wormhole.protocol = "4";
353 | 


--------------------------------------------------------------------------------
/web/ww.ts:
--------------------------------------------------------------------------------
  1 | /// <reference lib="es2018" />
  2 | /// <reference lib="dom" />
  3 | 
  4 | // Declare WASM symbols.
  5 | declare var webwormhole: {
  6 | 	decode(code: string): [number, Uint8Array];
  7 | 	encode(slot: number, pass: Uint8Array): string;
  8 | 	start(pass: Uint8Array): string;
  9 | 	exchange(pass: Uint8Array, msg: string): [Uint8Array, string];
 10 | 	finish(msg: string): Uint8Array;
 11 | 	open(key: Uint8Array, msg: string): string;
 12 | 	seal(key: Uint8Array, msg: string): string;
 13 | 	fingerprint(key: Uint8Array): Uint8Array;
 14 | 
 15 | 	match(prefix: string): string;
 16 | 	qrencode(url: string): Uint8Array;
 17 | };
 18 | 
 19 | // Declare Go WASM loader symbols.
 20 | declare class Go {
 21 | 	importObject: WebAssembly.Imports;
 22 | 	run(instance: WebAssembly.Instance): void;
 23 | }
 24 | 
 25 | // Error codes from webwormhole/dial.go.
 26 | enum WormholeErrorCodes {
 27 | 	closeNoSuchSlot = 4000,
 28 | 	closeSlotTimedOut = 4001,
 29 | 	closeNoMoreSlots = 4002,
 30 | 	closeWrongProto = 4003,
 31 | 	closePeerHungUp = 4004,
 32 | 	closeBadKey = 4005,
 33 | 	closeWebRTCSuccess = 4006,
 34 | 	closeWebRTCSuccessDirect = 4007,
 35 | 	closeWebRTCSuccessRelay = 4008,
 36 | 	closeWebRTCFailed = 4009,
 37 | }
 38 | 
 39 | type State = (msg: string) => Promise<State>;
 40 | 
 41 | class Wormhole {
 42 | 	// Signalling protocol version.
 43 | 	static readonly protocol = "4";
 44 | 
 45 | 	pass: Uint8Array;
 46 | 	signalserver: string;
 47 | 	slot?: number;
 48 | 	pc?: RTCPeerConnection;
 49 | 	ws?: WebSocket;
 50 | 	key?: Uint8Array;
 51 | 
 52 | 	state: State;
 53 | 	callback: (pc: RTCPeerConnection, newcode?: string) => void;
 54 | 	done: Promise<Uint8Array>;
 55 | 	resolve?: (fingerprint: Uint8Array) => void;
 56 | 	reject?: (reason: string) => void;
 57 | 
 58 | 	constructor(signalserver: string, code: string) {
 59 | 		this.signalserver = signalserver;
 60 | 		this.callback = () => {};
 61 | 		if (code !== "") {
 62 | 			[this.slot, this.pass] = webwormhole.decode(code);
 63 | 			if (this.pass.length === 0) {
 64 | 				throw "bad code";
 65 | 			}
 66 | 			console.log("dialling slot:", this.slot);
 67 | 			this.state = this.statePlayer2;
 68 | 		} else {
 69 | 			this.pass = crypto.getRandomValues(new Uint8Array(2));
 70 | 			console.log("requesting slot");
 71 | 			this.state = this.statePlayer1;
 72 | 		}
 73 | 
 74 | 		// There are 3 events that we need to synchronise with the caller on:
 75 | 		//   1. we got the first message from the signalling server.
 76 | 		//        We now have the slot number and the ICE server details, so we can
 77 | 		//        create the wormhole code and PeerConnection object, and pass them back
 78 | 		//        to the caller to display and configure, respectively.
 79 | 		//   2. the caller is done configuring the PeerConnection.
 80 | 		//        We can now create the offer or answer and send it to the peer.
 81 | 		//   3. we've successfully authenticated the other peer.
 82 | 		//        Signalling is now done, apart from trickling candidates. The caller
 83 | 		//        can display the key fingerprint.
 84 | 
 85 | 		this.done = new Promise((resolve, reject) => {
 86 | 			this.resolve = resolve;
 87 | 			this.reject = reject;
 88 | 		});
 89 | 	}
 90 | 
 91 | 	async statePlayer1(data: string): Promise<State> {
 92 | 		const msg: { slot: string; iceServers: RTCIceServer[] } = JSON.parse(data);
 93 | 
 94 | 		console.log("assigned slot:", msg.slot);
 95 | 		this.slot = parseInt(msg.slot, 10);
 96 | 		if (!Number.isSafeInteger(this.slot)) {
 97 | 			return this.fail("invalid slot");
 98 | 		}
 99 | 		this.pc = this.makePeerConnection(msg.iceServers);
100 | 		this.callback(this.pc, webwormhole.encode(this.slot, this.pass));
101 | 		return this.stateWaitForPAKEA;
102 | 	}
103 | 
104 | 	async statePlayer2(data: string): Promise<State> {
105 | 		if (!this.ws) {
106 | 			return this.fail("panic");
107 | 		}
108 | 
109 | 		const msg: { iceServers: RTCIceServer[] } = JSON.parse(data);
110 | 
111 | 		this.pc = this.makePeerConnection(msg.iceServers);
112 | 		this.callback(this.pc);
113 | 		const msgA = webwormhole.start(this.pass);
114 | 		if (!msgA) {
115 | 			return this.fail("could nnt generate A's PAKE message");
116 | 		}
117 | 		console.log("message a:", msgA);
118 | 		this.ws.send(msgA);
119 | 		return this.stateWaitForPAKEB;
120 | 	}
121 | 
122 | 	async stateWaitForPAKEA(data: string): Promise<State> {
123 | 		if (!this.ws || !this.pc) {
124 | 			return this.fail("panic");
125 | 		}
126 | 
127 | 		console.log("got pake message a:", data);
128 | 		let msgB;
129 | 		[this.key, msgB] = webwormhole.exchange(this.pass, data);
130 | 		console.log("message b:", msgB);
131 | 		if (!this.key) {
132 | 			return this.fail("could not generate key");
133 | 		}
134 | 		if (!msgB) {
135 | 			return this.fail("could not generate B's PAKE message");
136 | 		}
137 | 		console.log("generated key");
138 | 		this.ws.send(msgB);
139 | 
140 | 		this.state = this.stateWaitForLocalOffer;
141 | 		const offer = await this.pc.createOffer();
142 | 		console.log("created offer");
143 | 		this.ws.send(webwormhole.seal(this.key, JSON.stringify(offer)));
144 | 		this.pc.setLocalDescription(offer);
145 | 		return this.stateWaitForRemoteAnswer;
146 | 	}
147 | 
148 | 	async stateWaitForPAKEB(data: string): Promise<State> {
149 | 		console.log("got pake message b:", data);
150 | 		this.key = webwormhole.finish(data);
151 | 		if (!this.key) {
152 | 			return this.fail("could not generate key");
153 | 		}
154 | 		console.log("generated key");
155 | 		return this.stateWaitForRemoteOffer;
156 | 	}
157 | 
158 | 	async stateWaitForRemoteOffer(data: string): Promise<State> {
159 | 		if (!this.ws || !this.key || !this.pc || !this.resolve) {
160 | 			return this.fail("panic");
161 | 		}
162 | 
163 | 		const msg: RTCSessionDescriptionInit | null = JSON.parse(
164 | 			webwormhole.open(this.key, data)
165 | 		);
166 | 		if (!msg) {
167 | 			this.ws.send(webwormhole.seal(this.key, "bye"));
168 | 			this.ws.close(WormholeErrorCodes.closeBadKey);
169 | 			return this.fail("bad key");
170 | 		}
171 | 		if (msg.type !== "offer") {
172 | 			return this.fail("unexpected message: ${msg}");
173 | 		}
174 | 		console.log("got offer");
175 | 
176 | 		this.state = this.stateWaitForLocalAnswer;
177 | 		await this.pc.setRemoteDescription(new RTCSessionDescription(msg));
178 | 		const answer = await this.pc.createAnswer();
179 | 		console.log("created answer");
180 | 		this.ws.send(webwormhole.seal(this.key, JSON.stringify(answer)));
181 | 		this.resolve(webwormhole.fingerprint(this.key));
182 | 		this.pc.setLocalDescription(answer);
183 | 		return this.stateWaitForCandidates;
184 | 	}
185 | 
186 | 	async stateWaitForRemoteAnswer(data: string): Promise<State> {
187 | 		if (!this.ws || !this.key || !this.pc || !this.resolve) {
188 | 			return this.fail("panic");
189 | 		}
190 | 
191 | 		const msg: RTCSessionDescriptionInit | null = JSON.parse(
192 | 			webwormhole.open(this.key, data)
193 | 		);
194 | 		if (!msg) {
195 | 			this.ws.send(webwormhole.seal(this.key, "bye"));
196 | 			this.ws.close(WormholeErrorCodes.closeBadKey);
197 | 			return this.fail("bad key");
198 | 		}
199 | 		if (msg.type !== "answer") {
200 | 			return this.fail("unexpected message: ${msg}");
201 | 		}
202 | 		console.log("got answer");
203 | 		this.pc.setRemoteDescription(new RTCSessionDescription(msg));
204 | 		this.resolve(webwormhole.fingerprint(this.key));
205 | 		return this.stateWaitForCandidates;
206 | 	}
207 | 
208 | 	async stateWaitForCandidates(data: string): Promise<State> {
209 | 		if (!this.key || !this.pc) {
210 | 			return this.fail("panic");
211 | 		}
212 | 		this.processCandidate(data);
213 | 		return this.stateWaitForCandidates;
214 | 	}
215 | 
216 | 	async stateWaitForLocalOffer(data: string): Promise<State> {
217 | 		return this.fail(`unexpected message: ${data}`);
218 | 	}
219 | 
220 | 	async stateWaitForLocalAnswer(data: string): Promise<State> {
221 | 		// In this state we already got an offer and the WebRTC API is busy
222 | 		// making an answer. It's possible to get remote candidates from eager
223 | 		// peers now, but it's not safe to add them to this.pc on all browsers
224 | 		// just yet.
225 | 		// Delay processing the candidate until the handshake is done.
226 | 		// This "state" is special. It doesn't progress the state machine. The
227 | 		// stateWaitForRemoteOffer body moves us into and out of this state.
228 | 		await this.done;
229 | 		this.processCandidate(data);
230 | 		return this.state;
231 | 	}
232 | 
233 | 	async stateError(data: string): Promise<State> {
234 | 		return this.stateError;
235 | 	}
236 | 
237 | 	async close() {
238 | 		if (!this.ws || !this.pc) {
239 | 			return;
240 | 		}
241 | 
242 | 		switch (this.pc.iceConnectionState) {
243 | 			case "connected": {
244 | 				const connType = await this.connType();
245 | 				// TODO UI to warn if relay is used.
246 | 				console.log("webrtc connected:", connType);
247 | 				switch (connType) {
248 | 					case "host":
249 | 					case "srflx":
250 | 					case "prflx": {
251 | 						this.ws.close(WormholeErrorCodes.closeWebRTCSuccessDirect);
252 | 						break;
253 | 					}
254 | 					case "relay": {
255 | 						this.ws.close(WormholeErrorCodes.closeWebRTCSuccessRelay);
256 | 						break;
257 | 					}
258 | 					default: {
259 | 						this.ws.close(WormholeErrorCodes.closeWebRTCSuccess);
260 | 						break;
261 | 					}
262 | 				}
263 | 				break;
264 | 			}
265 | 			case "failed": {
266 | 				this.ws.close(WormholeErrorCodes.closeWebRTCFailed);
267 | 				break;
268 | 			}
269 | 		}
270 | 	}
271 | 
272 | 	processCandidate(data: string) {
273 | 		if (!this.ws || !this.key || !this.pc) {
274 | 			return;
275 | 		}
276 | 
277 | 		const msg: { candidate: string } | null = JSON.parse(
278 | 			webwormhole.open(this.key, data)
279 | 		);
280 | 		if (!msg) {
281 | 			this.fail("bad key");
282 | 			this.ws.send(webwormhole.seal(this.key, "bye"));
283 | 			this.ws.close(WormholeErrorCodes.closeBadKey);
284 | 			return;
285 | 		}
286 | 		console.log("got remote candidate", msg.candidate);
287 | 		this.pc.addIceCandidate(new RTCIceCandidate(msg));
288 | 		return;
289 | 	}
290 | 
291 | 	makePeerConnection(iceServers: RTCIceServer[]): RTCPeerConnection {
292 | 		const pc = new RTCPeerConnection({ iceServers: iceServers });
293 | 		pc.onicecandidate = (e: RTCPeerConnectionIceEvent) => {
294 | 			if (!this.ws || !this.key || !this.pc) {
295 | 				return;
296 | 			}
297 | 
298 | 			if (e.candidate && e.candidate.candidate !== "") {
299 | 				console.log("got local candidate", e.candidate.candidate);
300 | 				this.ws.send(webwormhole.seal(this.key, JSON.stringify(e.candidate)));
301 | 			}
302 | 		};
303 | 		return pc;
304 | 	}
305 | 
306 | 	async connType(): Promise<string> {
307 | 		if (!this.pc) {
308 | 			return "";
309 | 		}
310 | 
311 | 		// RTCStatsReport.forEach is all that's defined in the TypeScript DOM defs, which
312 | 		// makes this kind of awkward. Ah well.
313 | 		const stats = await this.pc.getStats();
314 | 
315 | 		let id: string | undefined;
316 | 		stats.forEach((s) => {
317 | 			// s.selected gives more confidenece than s.state == "succeeded", but Chrome does
318 | 			// not implement it.
319 | 			if (
320 | 				s.type === "candidate-pair" &&
321 | 				(s as RTCIceCandidatePairStats).state === "succeeded"
322 | 			) {
323 | 				id = (s as RTCIceCandidatePairStats).localCandidateId;
324 | 			}
325 | 		});
326 | 
327 | 		if (!id) {
328 | 			return "";
329 | 		}
330 | 
331 | 		let conntype: string = "";
332 | 		stats.forEach((s) => {
333 | 			if (s.id === id) {
334 | 				conntype = (s as { candidateType: string }).candidateType;
335 | 			}
336 | 		});
337 | 
338 | 		return conntype;
339 | 	}
340 | 
341 | 	async dial(): Promise<Uint8Array> {
342 | 		this.ws = new WebSocket(
343 | 			Wormhole.wsserver(this.signalserver, this.slot),
344 | 			Wormhole.protocol
345 | 		);
346 | 		// Use lambdas so that 'this' in the respective bodies refers to the Wormhole
347 | 		// instance, and not the WebSocket one.
348 | 		this.ws.onopen = () => this.onopen();
349 | 		this.ws.onerror = (e: Event) => this.onerror(e);
350 | 		this.ws.onclose = (e: CloseEvent) => this.onclose(e);
351 | 		this.ws.onmessage = (e: MessageEvent) => this.onmessage(e);
352 | 
353 | 		return this.done;
354 | 	}
355 | 
356 | 	async onmessage(m: MessageEvent) {
357 | 		if (!this.ws) {
358 | 			return;
359 | 		}
360 | 		// Feed the state machine a new message.
361 | 		this.state = await this.state(m.data);
362 | 	}
363 | 
364 | 	onopen() {
365 | 		console.log("websocket session established");
366 | 	}
367 | 
368 | 	onerror(e: Event) {
369 | 		console.log("websocket session error:", e);
370 | 		this.fail("could not connect to signalling server");
371 | 	}
372 | 
373 | 	onclose(e: CloseEvent) {
374 | 		switch (e.code) {
375 | 			case WormholeErrorCodes.closePeerHungUp:
376 | 			case 1000:
377 | 			case 1001: {
378 | 				// Normal closure of WebSocket.
379 | 				return;
380 | 			}
381 | 			case WormholeErrorCodes.closeNoSuchSlot: {
382 | 				this.fail("no such slot");
383 | 				return;
384 | 			}
385 | 			case WormholeErrorCodes.closeSlotTimedOut: {
386 | 				this.fail("timed out");
387 | 				return;
388 | 			}
389 | 			case WormholeErrorCodes.closeNoMoreSlots: {
390 | 				this.fail("could not get slot");
391 | 				return;
392 | 			}
393 | 			case WormholeErrorCodes.closeWrongProto: {
394 | 				this.fail("wrong protocol version: must update");
395 | 				return;
396 | 			}
397 | 			default: {
398 | 				this.fail(`websocket session closed: ${e.reason} (${e.code})`);
399 | 				return;
400 | 			}
401 | 		}
402 | 	}
403 | 
404 | 	fail(reason: string): State {
405 | 		if (this.reject) this.reject(reason);
406 | 		return this.stateError;
407 | 	}
408 | 
409 | 	// wsserver creates a WebSocket scheme (ws: or wss:) URL from an HTTP one.
410 | 	static wsserver(url: string, slot?: number) {
411 | 		const u = new URL(url);
412 | 		let protocol = "wss:";
413 | 		if (u.protocol === "http:") {
414 | 			protocol = "ws:";
415 | 		}
416 | 		let path = u.pathname;
417 | 		if (!path.startsWith("/")) {
418 | 			path = `/${path}`;
419 | 		}
420 | 		if (slot) {
421 | 			path = `${path}${slot}`;
422 | 		}
423 | 		return `${protocol}//${u.host}${path}`;
424 | 	}
425 | 
426 | 	// WASM loads the WebAssembly part from url.
427 | 	static async WASM(url: string) {
428 | 		// Polyfill for Safari WASM streaming.
429 | 		if (!WebAssembly.instantiateStreaming) {
430 | 			WebAssembly.instantiateStreaming = async (resp, importObject) => {
431 | 				const source = await (await resp).arrayBuffer();
432 | 				return await WebAssembly.instantiate(source, importObject);
433 | 			};
434 | 		}
435 | 		const go = new Go();
436 | 		const wasm = await WebAssembly.instantiateStreaming(
437 | 			fetch(url),
438 | 			go.importObject
439 | 		);
440 | 		go.run(wasm.instance);
441 | 	}
442 | }
443 | 


--------------------------------------------------------------------------------
/webdriver/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM debian:sid
2 | 
3 | RUN apt update && apt install -y chromium chromium-driver python3-selenium && apt clean
4 | 


--------------------------------------------------------------------------------
/webdriver/smoke.py:
--------------------------------------------------------------------------------
 1 | # a hacky smoke test that sends a file from one chrome window to another.
 2 | #   docker build -t ww-selenium .
 3 | #   docker run --rm -it -v $PWD:$PWD -w $PWD ww-selenium python3 ./smoke.py
 4 | # it isn't much but it's start.
 5 | # TODO:
 6 | #   - use go package / go test
 7 | #   - run the server
 8 | #   - eventually smoke test *all* client combinations. yes n². i can
 9 | #     count 9 clients (command line, firefox, chrome, firefox ext,
10 | #     chrome ext, safari, ios safari, android chrome, android firefox)
11 | #     81 transfers doesn't sound too bad.
12 | #   - add iptable rules to simulate nat/firewall scenarios and test
13 | #     ice.
14 | 
15 | from selenium import webdriver
16 | from selenium.webdriver.common.by import By
17 | from selenium.webdriver.common.keys import Keys
18 | from selenium.webdriver.support.ui import WebDriverWait
19 | from selenium.webdriver.support import expected_conditions as EC
20 | import time
21 | import tempfile
22 | import os
23 | import filecmp
24 | from os import path
25 | 
26 | indir = tempfile.TemporaryDirectory()
27 | print("in:", indir.name)
28 | outdir = tempfile.TemporaryDirectory()
29 | print("out:", outdir.name)
30 | 
31 | fpath = path.join(indir.name, "file.bin")
32 | with open(fpath, 'wb') as f:
33 | 	f.write(os.urandom(100<<10))
34 | 
35 | opts = webdriver.ChromeOptions()
36 | opts.headless = True
37 | opts.binary_location = '/usr/bin/chromium'
38 | # because in docker we run as root. TODO fix this.
39 | opts.add_argument("no-sandbox")
40 | 
41 | opts.add_experimental_option("prefs", {
42 | 	"download.default_directory": outdir.name,
43 | 	"download.prompt_for_download": False,
44 | 	"download.directory_upgrade": True,
45 | 	"safebrowsing.enabled": True
46 | })
47 | 
48 | driver1 = webdriver.Chrome(options=opts)
49 | driver2 = webdriver.Chrome(options=opts)
50 | 
51 | 
52 | try:
53 | 
54 | 	driver1.get("https://webwormhole.io")
55 | 	driver2.get("https://webwormhole.io")
56 | 	
57 | 	driver1.find_element(By.ID, 'dial').click()
58 | 	WebDriverWait(driver1, 10).until(
59 | 		EC.text_to_be_present_in_element((By.ID, "info"), "Waiting for")
60 | 	)
61 | 	assert driver1.find_element(By.ID, 'info').text.startswith("Waiting for the other")
62 | 
63 | 	code = driver1.find_element(By.ID, 'magiccode').get_attribute("value")
64 | 	assert len(code) != 0
65 | 	print(code)
66 | 
67 | 	driver2.find_element(By.ID, 'magiccode').send_keys(code)
68 | 	driver2.find_element(By.ID, 'dial').click()
69 | 
70 | 	WebDriverWait(driver1, 10).until(
71 | 		EC.visibility_of(driver1.find_element(By.ID, "top"))
72 | 	)
73 | 	WebDriverWait(driver2, 10).until(
74 | 		EC.visibility_of(driver2.find_element(By.ID, "top"))
75 | 	)
76 | 
77 | 	driver1.find_element(By.ID, 'filepicker').send_keys(fpath)
78 | 
79 | 	time.sleep(3)
80 | 	assert filecmp.cmp(fpath, path.join(outdir.name, "file.bin"))
81 | 
82 | 	print("success")
83 | 
84 | finally:
85 | 	driver1.quit()
86 | 	driver2.quit()
87 | 


--------------------------------------------------------------------------------
/wordlist/wordlist.go:
--------------------------------------------------------------------------------
  1 | // Package wordlist provides a encoders and a decoder for WebWormhole codes.
  2 | package wordlist
  3 | 
  4 | import (
  5 | 	"encoding/binary"
  6 | 	"fmt"
  7 | 	"strconv"
  8 | 	"strings"
  9 | )
 10 | 
 11 | var defaultEncodings = []encoding{
 12 | 	varintEncoding(enWords),
 13 | 	magicWormholeEncoding(enWords),
 14 | 	magicWormholeEncoding(pgpWords),
 15 | 	octalEncoding{},
 16 | }
 17 | 
 18 | // Encode returns the string encoding of slot and pass using the default encoding,
 19 | // which is english-varint-slot.
 20 | func Encode(slot int, pass []byte) string {
 21 | 	return defaultEncodings[0].Encode(slot, pass)
 22 | }
 23 | 
 24 | // Encode returns the slot and pass encoded by code, trying all supported word lists
 25 | // supported in the default order. Invalid codes return a 0 slot and a nil pass.
 26 | func Decode(code string) (slot int, pass []byte) {
 27 | 	for _, enc := range defaultEncodings {
 28 | 		s, p := enc.Decode(code)
 29 | 		if p != nil {
 30 | 			return s, p
 31 | 		}
 32 | 	}
 33 | 	return 0, nil
 34 | }
 35 | 
 36 | // Match returns the first word in the word list that has prefix prefix, trying all
 37 | // supported word lists the default order. It returns the empty string if none match.
 38 | func Match(prefix string) string {
 39 | 	for _, enc := range defaultEncodings {
 40 | 		hint := enc.Match(prefix)
 41 | 		if hint != "" {
 42 | 			return hint
 43 | 		}
 44 | 	}
 45 | 	return ""
 46 | }
 47 | 
 48 | // encoding is a string encoding for a vector of bytes.
 49 | type encoding interface {
 50 | 	// Encode returns the string encoding of slot and pass.
 51 | 	Encode(slot int, pass []byte) string
 52 | 	// Encode returns the slot and pass encoded by code.
 53 | 	Decode(code string) (slot int, pass []byte)
 54 | 	// Match returns the first word in the word list that has prefix prefix.
 55 | 	Match(prefix string) string
 56 | }
 57 | 
 58 | // octalEncoding map is a numeric encoding of the codes.
 59 | type octalEncoding struct{}
 60 | 
 61 | func (octalEncoding) Encode(slot int, pass []byte) string {
 62 | 	if len(pass) == 0 {
 63 | 		return ""
 64 | 	}
 65 | 
 66 | 	code := fmt.Sprintf("%o", slot)
 67 | 	for i, b := range pass {
 68 | 		code += fmt.Sprintf("-%03o", int(b)|((i&1)<<8)) // each byte b + a 9th parity bit
 69 | 	}
 70 | 	return code
 71 | }
 72 | 
 73 | func (octalEncoding) Decode(code string) (slot int, pass []byte) {
 74 | 	// White space and - are interchangable.
 75 | 	code = strings.ReplaceAll(code, "-", " ")
 76 | 	// Space can turn into + in URLs.
 77 | 	code = strings.ReplaceAll(code, "+", " ")
 78 | 	parts := strings.Fields(code)
 79 | 	if len(parts) < 2 {
 80 | 		return 0, nil
 81 | 	}
 82 | 
 83 | 	s, err := strconv.ParseInt(parts[0], 8, 64)
 84 | 	if err != nil {
 85 | 		return 0, nil
 86 | 	}
 87 | 
 88 | 	pass = make([]byte, len(parts[1:]))
 89 | 	for i, p := range parts[1:] {
 90 | 		n, err := strconv.ParseInt(p, 8, 16)
 91 | 		if err != nil {
 92 | 			return 0, nil
 93 | 		}
 94 | 		if int((n>>8)&1) != i%2 {
 95 | 			return 0, nil
 96 | 		}
 97 | 		pass[i] = byte(n & 0xff)
 98 | 	}
 99 | 	return int(s), pass
100 | }
101 | 
102 | func (octalEncoding) Match(prefix string) string { return "" }
103 | 
104 | // varintEncoding maps codes into a word for each byte, with the slot encoded as a
105 | // varint at the start. E.g. foo-bar-baz.
106 | type varintEncoding []string
107 | 
108 | func (list varintEncoding) Encode(slot int, pass []byte) string {
109 | 	if len(pass) == 0 {
110 | 		return ""
111 | 	}
112 | 	slotbytes := make([]byte, binary.MaxVarintLen64)
113 | 	n := binary.PutUvarint(slotbytes, uint64(slot))
114 | 	slotbytes = slotbytes[:n]
115 | 
116 | 	words := make([]string, n+len(pass))
117 | 	for i := range slotbytes {
118 | 		words[i] = list[int(slotbytes[i])*2+i%2]
119 | 	}
120 | 	for i := range pass {
121 | 		words[n+i] = list[int(pass[i])*2+(n+i)%2]
122 | 	}
123 | 	return strings.Join(words, "-")
124 | }
125 | 
126 | func (list varintEncoding) Decode(code string) (slot int, pass []byte) {
127 | 	// White space and - are interchangable.
128 | 	code = strings.ReplaceAll(code, "-", " ")
129 | 	// Space can turn into + in URLs.
130 | 	code = strings.ReplaceAll(code, "+", " ")
131 | 	parts := strings.Fields(code)
132 | 
133 | 	buf := make([]byte, len(parts))
134 | 	for i := range parts {
135 | 		j := indexOf([]string(list), parts[i])
136 | 		if j < 0 {
137 | 			return 0, nil
138 | 		}
139 | 		buf[i] = byte(j / 2)
140 | 		if i%2 != j%2 {
141 | 			return 0, nil
142 | 		}
143 | 	}
144 | 
145 | 	s, n := binary.Uvarint(buf)
146 | 	if n <= 0 {
147 | 		return 0, nil
148 | 	}
149 | 	return int(s), buf[n:]
150 | }
151 | 
152 | func (list varintEncoding) Match(prefix string) string {
153 | 	return match([]string(list), prefix)
154 | }
155 | 
156 | // magicWormholeEncoding maps codes into a word for each byte, with the slot encoded
157 | // as an integer at the start. E.g. 5-foo-bar.
158 | type magicWormholeEncoding []string
159 | 
160 | func (list magicWormholeEncoding) Encode(slot int, pass []byte) string {
161 | 	if len(pass) == 0 {
162 | 		return ""
163 | 	}
164 | 	code := fmt.Sprintf("%d", slot)
165 | 	for i := range pass {
166 | 		code += fmt.Sprintf("-%s", list[int(pass[i])*2+i%2])
167 | 	}
168 | 	return code
169 | }
170 | 
171 | func (list magicWormholeEncoding) Decode(code string) (slot int, pass []byte) {
172 | 	// White space and - are interchangable.
173 | 	code = strings.ReplaceAll(code, "-", " ")
174 | 	// Space can turn into + in URLs.
175 | 	code = strings.ReplaceAll(code, "+", " ")
176 | 	parts := strings.Fields(code)
177 | 	if len(parts) < 2 {
178 | 		return 0, nil
179 | 	}
180 | 
181 | 	slot, err := strconv.Atoi(parts[0])
182 | 	if err != nil {
183 | 		return 0, nil
184 | 	}
185 | 
186 | 	pass = make([]byte, len(parts[1:]))
187 | 	for i, p := range parts[1:] {
188 | 		j := indexOf(list, p)
189 | 		if j < 0 {
190 | 			return 0, nil // word not in dict
191 | 		}
192 | 		pass[i] = byte(j / 2)
193 | 		if i%2 != j%2 {
194 | 			return 0, nil // bad parity
195 | 		}
196 | 	}
197 | 	return slot, pass
198 | }
199 | 
200 | func (list magicWormholeEncoding) Match(prefix string) string {
201 | 	return match([]string(list), prefix)
202 | }
203 | 
204 | // indexOf finds the index of word in list. It returns -1 if it is not in the list.
205 | func indexOf(list []string, word string) int {
206 | 	for i := range list {
207 | 		if strings.EqualFold(word, list[i]) {
208 | 			return i
209 | 		}
210 | 	}
211 | 	return -1
212 | }
213 | 
214 | func match(list []string, prefix string) string {
215 | 	if prefix == "" {
216 | 		return ""
217 | 	}
218 | 	for i := range list {
219 | 		if strings.HasPrefix(list[i], prefix) {
220 | 			return list[i]
221 | 		}
222 | 	}
223 | 	return ""
224 | }
225 | 
226 | // enWords is based on the EFF short wordlist, filtered by unique soundex.
227 | // https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases
228 | // Credit to Nick Moore https://nick.zoic.org/art/shorter-words-list/
229 | var enWords = []string{
230 | 	"acorn", "acre",
231 | 	"acts", "afar",
232 | 	"affix", "aged",
233 | 	"agent", "agile",
234 | 	"aging", "agony",
235 | 	"aide", "aids",
236 | 	"aim", "alarm",
237 | 	"alike", "alive",
238 | 	"aloe", "aloft",
239 | 	"alone", "amend",
240 | 	"ample", "amuse",
241 | 	"angel", "anger",
242 | 	"apple", "april",
243 | 	"apron", "area",
244 | 	"argue", "armed",
245 | 	"armor", "army",
246 | 	"arson", "art",
247 | 	"atlas", "atom",
248 | 	"avert", "avoid",
249 | 	"axis", "bacon",
250 | 	"baker", "balmy",
251 | 	"barn", "basil",
252 | 	"baton", "bats",
253 | 	"blank", "blast",
254 | 	"blend", "blimp",
255 | 	"blob", "blog",
256 | 	"blurt", "boil",
257 | 	"bok", "bolt",
258 | 	"bony", "bribe",
259 | 	"bring", "broad",
260 | 	"broil", "broke",
261 | 	"bud", "bunch",
262 | 	"bunt", "bust",
263 | 	"calm", "canal",
264 | 	"candy", "card",
265 | 	"case", "cedar",
266 | 	"chump", "civic",
267 | 	"civil", "clamp",
268 | 	"clasp", "class",
269 | 	"clay", "clear",
270 | 	"cleft", "clerk",
271 | 	"cling", "clip",
272 | 	"cold", "come",
273 | 	"comic", "cork",
274 | 	"cost", "cover",
275 | 	"craft", "cramp",
276 | 	"crank", "crisp",
277 | 	"crop", "crown",
278 | 	"crust", "cub",
279 | 	"cupid", "cure",
280 | 	"curl", "cut",
281 | 	"cycle", "dab",
282 | 	"dad", "dart",
283 | 	"deal", "debt",
284 | 	"debug", "decaf",
285 | 	"decal", "decor",
286 | 	"dent", "dig",
287 | 	"dimly", "ditch",
288 | 	"doing", "donor",
289 | 	"down", "drab",
290 | 	"drank", "dress",
291 | 	"drift", "drill",
292 | 	"drum", "dry",
293 | 	"dust", "early",
294 | 	"earth", "east",
295 | 	"eaten", "ebony",
296 | 	"echo", "edge",
297 | 	"eel", "elder",
298 | 	"elf", "elk",
299 | 	"elm", "elude",
300 | 	"elves", "email",
301 | 	"emit", "empty",
302 | 	"emu", "enter",
303 | 	"envoy", "equal",
304 | 	"erase", "error",
305 | 	"erupt", "evade",
306 | 	"even", "evict",
307 | 	"evil", "evoke",
308 | 	"fable", "fact",
309 | 	"fall", "fang",
310 | 	"femur", "fend",
311 | 	"fetal", "fetch",
312 | 	"fever", "fifth",
313 | 	"film", "final",
314 | 	"fit", "five",
315 | 	"flag", "fled",
316 | 	"fling", "flint",
317 | 	"flip", "flirt",
318 | 	"flyer", "foam",
319 | 	"fox", "frail",
320 | 	"fray", "fresh",
321 | 	"from", "front",
322 | 	"frost", "fruit",
323 | 	"gap", "gas",
324 | 	"gem", "genre",
325 | 	"gift", "given",
326 | 	"giver", "glad",
327 | 	"glass", "goal",
328 | 	"golf", "gong",
329 | 	"grab", "grant",
330 | 	"grasp", "grass",
331 | 	"green", "grew",
332 | 	"grid", "grill",
333 | 	"gut", "habit",
334 | 	"halt", "harm",
335 | 	"hasty", "hatch",
336 | 	"haven", "hazel",
337 | 	"help", "herbs",
338 | 	"hers", "hub",
339 | 	"hug", "hull",
340 | 	"human", "hump",
341 | 	"hung", "hunt",
342 | 	"hurry", "hurt",
343 | 	"hut", "ice",
344 | 	"icing", "icon",
345 | 	"igloo", "image",
346 | 	"ion", "iron",
347 | 	"item", "ivory",
348 | 	"ivy", "jam",
349 | 	"jet", "job",
350 | 	"jog", "jolt",
351 | 	"judge", "july",
352 | 	"jump", "junky",
353 | 	"jury", "keep",
354 | 	"keg", "kept",
355 | 	"kilt", "king",
356 | 	"kite", "knee",
357 | 	"knelt", "koala",
358 | 	"ladle", "lake",
359 | 	"land", "last",
360 | 	"latch", "left",
361 | 	"legal", "lens",
362 | 	"level", "lid",
363 | 	"lilac", "lily",
364 | 	"limb", "line",
365 | 	"lip", "liver",
366 | 	"lunar", "lure",
367 | 	"lurk", "maker",
368 | 	"mango", "manor",
369 | 	"map", "march",
370 | 	"mardi", "marry",
371 | 	"match", "malt",
372 | 	"mom", "most",
373 | 	"motor", "mount",
374 | 	"mud", "mug",
375 | 	"mulch", "mule",
376 | 	"mumbo", "mural",
377 | 	"nag", "nail",
378 | 	"name", "nap",
379 | 	"near", "nerd",
380 | 	"net", "next",
381 | 	"ninth", "oak",
382 | 	"oat", "ocean",
383 | 	"oil", "old",
384 | 	"olive", "omen",
385 | 	"only", "open",
386 | 	"opera", "opt",
387 | 	"ounce", "outer",
388 | 	"oval", "pagan",
389 | 	"palm", "pants",
390 | 	"paper", "park",
391 | 	"party", "patch",
392 | 	"pep", "perm",
393 | 	"pest", "petal",
394 | 	"petri", "plank",
395 | 	"plant", "plot",
396 | 	"plus", "pod",
397 | 	"poem", "poker",
398 | 	"polar", "pond",
399 | 	"prank", "print",
400 | 	"prism", "proof",
401 | 	"props", "pry",
402 | 	"pug", "pull",
403 | 	"pulp", "punk",
404 | 	"pupil", "quake",
405 | 	"query", "quill",
406 | 	"quit", "rabid",
407 | 	"radar", "raft",
408 | 	"ramp", "rank",
409 | 	"rant", "recap",
410 | 	"relax", "reply",
411 | 	"rerun", "rigor",
412 | 	"ritzy", "river",
413 | 	"robin", "rope",
414 | 	"rug", "ruin",
415 | 	"rule", "rust",
416 | 	"rut", "salt",
417 | 	"same", "scale",
418 | 	"scan", "scold",
419 | 	"score", "scorn",
420 | 	"scrap", "sect",
421 | 	"self", "send",
422 | 	"set", "seven",
423 | 	"share", "shirt",
424 | 	"shrug", "silk",
425 | 	"silo", "sip",
426 | 	"siren", "skip",
427 | 	"skirt", "sky",
428 | 	"slam", "slang",
429 | 	"slept", "slurp",
430 | 	"small", "smirk",
431 | 	"smog", "snap",
432 | 	"snare", "snarl",
433 | 	"snort", "speak",
434 | 	"spent", "spill",
435 | 	"sport", "spot",
436 | 	"spur", "stamp",
437 | 	"stand", "stark",
438 | 	"start", "stem",
439 | 	"sting", "stir",
440 | 	"stole", "stop",
441 | 	"storm", "suds",
442 | 	"surf", "swirl",
443 | 	"tag", "tall",
444 | 	"talon", "tamer",
445 | 	"tank", "taper",
446 | 	"taps", "tart",
447 | 	"taste", "theft",
448 | 	"thumb", "tidal",
449 | 	"tidy", "tiger",
450 | 	"tilt", "tint",
451 | 	"tiny", "train",
452 | 	"trap", "trek",
453 | 	"trend", "trial",
454 | 	"trunk", "try",
455 | 	"tulip", "tutor",
456 | 	"uncle", "uncut",
457 | 	"unify", "union",
458 | 	"unit", "upon",
459 | 	"upper", "urban",
460 | 	"used", "user",
461 | 	"utter", "value",
462 | 	"vapor", "vegan",
463 | 	"venue", "vest",
464 | 	"vice", "viral",
465 | 	"virus", "visor",
466 | 	"vocal", "void",
467 | 	"volt", "voter",
468 | 	"wad", "wafer",
469 | 	"wager", "wagon",
470 | 	"walk", "wasp",
471 | 	"watch", "water",
472 | 	"widen", "wife",
473 | 	"wilt", "wind",
474 | 	"wing", "wiry",
475 | 	"wok", "wolf",
476 | 	"womb", "wool",
477 | 	"word", "work",
478 | 	"woven", "wrist",
479 | 	"xerox", "yam",
480 | 	"yard", "year",
481 | 	"yeast", "yelp",
482 | 	"yield", "yodel",
483 | 	"yoga", "zebra",
484 | 	"zero", "zesty",
485 | 	"zippy", "zone",
486 | }
487 | 
488 | // pgpWords is the PGP word list encoding.
489 | // https://en.wikipedia.org/wiki/PGP_word_list
490 | var pgpWords = []string{
491 | 	"aardvark", "adroitness",
492 | 	"absurd", "adviser",
493 | 	"accrue", "aftermath",
494 | 	"acme", "aggregate",
495 | 	"adrift", "alkali",
496 | 	"adult", "almighty",
497 | 	"afflict", "amulet",
498 | 	"ahead", "amusement",
499 | 	"aimless", "antenna",
500 | 	"algol", "applicant",
501 | 	"allow", "apollo",
502 | 	"alone", "armistice",
503 | 	"ammo", "article",
504 | 	"ancient", "asteroid",
505 | 	"apple", "atlantic",
506 | 	"artist", "atmosphere",
507 | 	"assume", "autopsy",
508 | 	"athens", "babylon",
509 | 	"atlas", "backwater",
510 | 	"aztec", "barbecue",
511 | 	"baboon", "belowground",
512 | 	"backfield", "bifocals",
513 | 	"backward", "bodyguard",
514 | 	"banjo", "bookseller",
515 | 	"beaming", "borderline",
516 | 	"bedlamp", "bottomless",
517 | 	"beehive", "bradbury",
518 | 	"beeswax", "bravado",
519 | 	"befriend", "brazilian",
520 | 	"belfast", "breakaway",
521 | 	"berserk", "burlington",
522 | 	"billiard", "businessman",
523 | 	"bison", "butterfat",
524 | 	"blackjack", "camelot",
525 | 	"blockade", "candidate",
526 | 	"blowtorch", "cannonball",
527 | 	"bluebird", "capricorn",
528 | 	"bombast", "caravan",
529 | 	"bookshelf", "caretaker",
530 | 	"brackish", "celebrate",
531 | 	"breadline", "cellulose",
532 | 	"breakup", "certify",
533 | 	"brickyard", "chambermaid",
534 | 	"briefcase", "cherokee",
535 | 	"burbank", "chicago",
536 | 	"button", "clergyman",
537 | 	"buzzard", "coherence",
538 | 	"cement", "combustion",
539 | 	"chairlift", "commando",
540 | 	"chatter", "company",
541 | 	"checkup", "component",
542 | 	"chisel", "concurrent",
543 | 	"choking", "confidence",
544 | 	"chopper", "conformist",
545 | 	"christmas", "congregate",
546 | 	"clamshell", "consensus",
547 | 	"classic", "consulting",
548 | 	"classroom", "corporate",
549 | 	"cleanup", "corrosion",
550 | 	"clockwork", "councilman",
551 | 	"cobra", "crossover",
552 | 	"commence", "crucifix",
553 | 	"concert", "cumbersome",
554 | 	"cowbell", "customer",
555 | 	"crackdown", "dakota",
556 | 	"cranky", "decadence",
557 | 	"crowfoot", "december",
558 | 	"crucial", "decimal",
559 | 	"crumpled", "designing",
560 | 	"crusade", "detector",
561 | 	"cubic", "detergent",
562 | 	"dashboard", "determine",
563 | 	"deadbolt", "dictator",
564 | 	"deckhand", "dinosaur",
565 | 	"dogsled", "direction",
566 | 	"dragnet", "disable",
567 | 	"drainage", "disbelief",
568 | 	"dreadful", "disruptive",
569 | 	"drifter", "distortion",
570 | 	"dropper", "document",
571 | 	"drumbeat", "embezzle",
572 | 	"drunken", "enchanting",
573 | 	"dupont", "enrollment",
574 | 	"dwelling", "enterprise",
575 | 	"eating", "equation",
576 | 	"edict", "equipment",
577 | 	"egghead", "escapade",
578 | 	"eightball", "eskimo",
579 | 	"endorse", "everyday",
580 | 	"endow", "examine",
581 | 	"enlist", "existence",
582 | 	"erase", "exodus",
583 | 	"escape", "fascinate",
584 | 	"exceed", "filament",
585 | 	"eyeglass", "finicky",
586 | 	"eyetooth", "forever",
587 | 	"facial", "fortitude",
588 | 	"fallout", "frequency",
589 | 	"flagpole", "gadgetry",
590 | 	"flatfoot", "galveston",
591 | 	"flytrap", "getaway",
592 | 	"fracture", "glossary",
593 | 	"framework", "gossamer",
594 | 	"freedom", "graduate",
595 | 	"frighten", "gravity",
596 | 	"gazelle", "guitarist",
597 | 	"geiger", "hamburger",
598 | 	"glitter", "hamilton",
599 | 	"glucose", "handiwork",
600 | 	"goggles", "hazardous",
601 | 	"goldfish", "headwaters",
602 | 	"gremlin", "hemisphere",
603 | 	"guidance", "hesitate",
604 | 	"hamlet", "hideaway",
605 | 	"highchair", "holiness",
606 | 	"hockey", "hurricane",
607 | 	"indoors", "hydraulic",
608 | 	"indulge", "impartial",
609 | 	"inverse", "impetus",
610 | 	"involve", "inception",
611 | 	"island", "indigo",
612 | 	"jawbone", "inertia",
613 | 	"keyboard", "infancy",
614 | 	"kickoff", "inferno",
615 | 	"kiwi", "informant",
616 | 	"klaxon", "insincere",
617 | 	"locale", "insurgent",
618 | 	"lockup", "integrate",
619 | 	"merit", "intention",
620 | 	"minnow", "inventive",
621 | 	"miser", "istanbul",
622 | 	"mohawk", "jamaica",
623 | 	"mural", "jupiter",
624 | 	"music", "leprosy",
625 | 	"necklace", "letterhead",
626 | 	"neptune", "liberty",
627 | 	"newborn", "maritime",
628 | 	"nightbird", "matchmaker",
629 | 	"oakland", "maverick",
630 | 	"obtuse", "medusa",
631 | 	"offload", "megaton",
632 | 	"optic", "microscope",
633 | 	"orca", "microwave",
634 | 	"payday", "midsummer",
635 | 	"peachy", "millionaire",
636 | 	"pheasant", "miracle",
637 | 	"physique", "misnomer",
638 | 	"playhouse", "molasses",
639 | 	"pluto", "molecule",
640 | 	"preclude", "montana",
641 | 	"prefer", "monument",
642 | 	"preshrunk", "mosquito",
643 | 	"printer", "narrative",
644 | 	"prowler", "nebula",
645 | 	"pupil", "newsletter",
646 | 	"puppy", "norwegian",
647 | 	"python", "october",
648 | 	"quadrant", "ohio",
649 | 	"quiver", "onlooker",
650 | 	"quota", "opulent",
651 | 	"ragtime", "orlando",
652 | 	"ratchet", "outfielder",
653 | 	"rebirth", "pacific",
654 | 	"reform", "pandemic",
655 | 	"regain", "pandora",
656 | 	"reindeer", "paperweight",
657 | 	"rematch", "paragon",
658 | 	"repay", "paragraph",
659 | 	"retouch", "paramount",
660 | 	"revenge", "passenger",
661 | 	"reward", "pedigree",
662 | 	"rhythm", "pegasus",
663 | 	"ribcage", "penetrate",
664 | 	"ringbolt", "perceptive",
665 | 	"robust", "performance",
666 | 	"rocker", "pharmacy",
667 | 	"ruffled", "phonetic",
668 | 	"sailboat", "photograph",
669 | 	"sawdust", "pioneer",
670 | 	"scallion", "pocketful",
671 | 	"scenic", "politeness",
672 | 	"scorecard", "positive",
673 | 	"scotland", "potato",
674 | 	"seabird", "processor",
675 | 	"select", "provincial",
676 | 	"sentence", "proximate",
677 | 	"shadow", "puberty",
678 | 	"shamrock", "publisher",
679 | 	"showgirl", "pyramid",
680 | 	"skullcap", "quantity",
681 | 	"skydive", "racketeer",
682 | 	"slingshot", "rebellion",
683 | 	"slowdown", "recipe",
684 | 	"snapline", "recover",
685 | 	"snapshot", "repellent",
686 | 	"snowcap", "replica",
687 | 	"snowslide", "reproduce",
688 | 	"solo", "resistor",
689 | 	"southward", "responsive",
690 | 	"soybean", "retraction",
691 | 	"spaniel", "retrieval",
692 | 	"spearhead", "retrospect",
693 | 	"spellbind", "revenue",
694 | 	"spheroid", "revival",
695 | 	"spigot", "revolver",
696 | 	"spindle", "sandalwood",
697 | 	"spyglass", "sardonic",
698 | 	"stagehand", "saturday",
699 | 	"stagnate", "savagery",
700 | 	"stairway", "scavenger",
701 | 	"standard", "sensation",
702 | 	"stapler", "sociable",
703 | 	"steamship", "souvenir",
704 | 	"sterling", "specialist",
705 | 	"stockman", "speculate",
706 | 	"stopwatch", "stethoscope",
707 | 	"stormy", "stupendous",
708 | 	"sugar", "supportive",
709 | 	"surmount", "surrender",
710 | 	"suspense", "suspicious",
711 | 	"sweatband", "sympathy",
712 | 	"swelter", "tambourine",
713 | 	"tactics", "telephone",
714 | 	"talon", "therapist",
715 | 	"tapeworm", "tobacco",
716 | 	"tempest", "tolerance",
717 | 	"tiger", "tomorrow",
718 | 	"tissue", "torpedo",
719 | 	"tonic", "tradition",
720 | 	"topmost", "travesty",
721 | 	"tracker", "trombonist",
722 | 	"transit", "truncated",
723 | 	"trauma", "typewriter",
724 | 	"treadmill", "ultimate",
725 | 	"trojan", "undaunted",
726 | 	"trouble", "underfoot",
727 | 	"tumor", "unicorn",
728 | 	"tunnel", "unify",
729 | 	"tycoon", "universe",
730 | 	"uncut", "unravel",
731 | 	"unearth", "upcoming",
732 | 	"unwind", "vacancy",
733 | 	"uproot", "vagabond",
734 | 	"upset", "vertigo",
735 | 	"upshot", "virginia",
736 | 	"vapor", "visitor",
737 | 	"village", "vocalist",
738 | 	"virus", "voyager",
739 | 	"vulcan", "warranty",
740 | 	"waffle", "waterloo",
741 | 	"wallet", "whimsical",
742 | 	"watchword", "wichita",
743 | 	"wayside", "wilmington",
744 | 	"willow", "wyoming",
745 | 	"woodlark", "yesteryear",
746 | 	"zulu", "yucatan",
747 | }
748 | 


--------------------------------------------------------------------------------
/wordlist/wordlist_test.go:
--------------------------------------------------------------------------------
 1 | package wordlist
 2 | 
 3 | import (
 4 | 	"reflect"
 5 | 	"testing"
 6 | )
 7 | 
 8 | func TestEnEncodeDecode(t *testing.T) {
 9 | 	cases := []struct {
10 | 		slot int
11 | 		pass []byte
12 | 		code string
13 | 	}{
14 | 		{0, nil, ""},
15 | 		{2, []byte{0}, "affix-acre"},
16 | 		{2, []byte{0, 0}, "affix-acre-acorn"},
17 | 		{2, []byte{8, 8}, "affix-aloft-aloe"},
18 | 		{127, []byte{1}, "knelt-afar"},
19 | 		{128, []byte{1}, "ladle-afar-acts"},
20 | 		{255, []byte{1}, "zippy-afar-acts"},
21 | 		{256, []byte{1}, "ladle-aged-acts"},
22 | 		{256, []byte{8, 8}, "ladle-aged-aloe-aloft"},
23 | 	}
24 | 	for i, c := range cases {
25 | 		if code := Encode(c.slot, c.pass); code != c.code {
26 | 			t.Errorf("encode testcase %v got %v want %v", i, code, c.code)
27 | 		}
28 | 	}
29 | 	for i, c := range cases {
30 | 		if slot, pass := Decode(c.code); slot != c.slot || !reflect.DeepEqual(pass, c.pass) {
31 | 			t.Errorf("decode testcase %v got %v,%v want %v,%v", i, slot, pass, c.slot, c.pass)
32 | 		}
33 | 	}
34 | }
35 | 
36 | func TestMatch(t *testing.T) {
37 | 	cases := []struct {
38 | 		prefix string
39 | 		word   string
40 | 	}{
41 | 		{"", ""},
42 | 		{"a", "acorn"},
43 | 		{"ac", "acorn"},
44 | 		{"act", "acts"},
45 | 		{"acre-", ""},
46 | 		{"acre-b", ""},
47 | 		{"zo", "zone"},
48 | 		{"acre-b", ""},
49 | 		{"zz", ""},
50 | 		{"snaps", "snapshot"}, // fallback to gpg words
51 | 	}
52 | 	for i, c := range cases {
53 | 		if hint := Match(c.prefix); hint != c.word {
54 | 			t.Errorf("testcase %v (%v) got %v want %v", i, c.prefix, hint, c.word)
55 | 		}
56 | 	}
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/wormhole/dial.go:
--------------------------------------------------------------------------------
  1 | // Package wormhole implements a signalling protocol to establish password protected
  2 | // WebRTC connections between peers.
  3 | //
  4 | // WebRTC uses DTLS-SRTP (https://tools.ietf.org/html/rfc5764) to secure its
  5 | // data. The mechanism it uses to exchange keys relies on exchanging metadata
  6 | // that includes both endpoints' certificate fingerprints via some trusted channel,
  7 | // typically a signalling server over https and websockets. More in RFC5763
  8 | // (https://tools.ietf.org/html/rfc5763).
  9 | //
 10 | // This package removes the signalling server from the trust model by using a
 11 | // PAKE to estabish the authenticity of the WebRTC metadata. In other words,
 12 | // it's a clone of Magic Wormhole made to use WebRTC as the transport.
 13 | //
 14 | // The protocol requires a signalling server that facilitates exchanging
 15 | // arbitrary messages via a slot system. The server subcommand of the
 16 | // ww tool is an implementation of this over WebSockets.
 17 | //
 18 | // Rough sketch of the handshake:
 19 | //
 20 | //	Peer               Signalling Server                Peer
 21 | //	----open------------------> |
 22 | //	<---new_slot,TURN_ticket--- |
 23 | //	                            | <------------------open----
 24 | //	                            | ------------TURN_ticket--->
 25 | //	<---------------------------|--------------pake_msg_a----
 26 | //	----pake_msg_b--------------|--------------------------->
 27 | //	----sbox(offer)-------------|--------------------------->
 28 | //	<---------------------------|------------sbox(answer)----
 29 | //	----sbox(candidates...)-----|--------------------------->
 30 | //	<---------------------------|-----sbox(candidates...)----
 31 | package wormhole
 32 | 
 33 | import (
 34 | 	"context"
 35 | 	crand "crypto/rand"
 36 | 	"crypto/sha256"
 37 | 	"encoding/base64"
 38 | 	"encoding/json"
 39 | 	"errors"
 40 | 	"io"
 41 | 	"log"
 42 | 	"net/url"
 43 | 	"sync"
 44 | 	"time"
 45 | 
 46 | 	"filippo.io/cpace"
 47 | 	webrtc "github.com/pion/webrtc/v3"
 48 | 	"golang.org/x/crypto/hkdf"
 49 | 	"golang.org/x/crypto/nacl/secretbox"
 50 | 	"golang.org/x/net/proxy"
 51 | 	"nhooyr.io/websocket"
 52 | )
 53 | 
 54 | // Protocol is an identifier for the current signalling scheme. It's
 55 | // intended to help clients print a friendlier message urging them to
 56 | // upgrade if the signalling server has a different version.
 57 | const Protocol = "4"
 58 | 
 59 | const (
 60 | 	// CloseNoSuchSlot is the WebSocket status returned if the slot is not valid.
 61 | 	CloseNoSuchSlot = 4000 + iota
 62 | 
 63 | 	// CloseSlotTimedOut is the WebSocket status returned when the slot times out.
 64 | 	CloseSlotTimedOut
 65 | 
 66 | 	// CloseNoMoreSlots is the WebSocket status returned when the signalling server
 67 | 	// cannot allocate any new slots at the time.
 68 | 	CloseNoMoreSlots
 69 | 
 70 | 	// CloseWrongProto is the WebSocket status returned when the signalling server
 71 | 	// runs a different version of the signalling protocol.
 72 | 	CloseWrongProto
 73 | 
 74 | 	// ClosePeerHungUp is the WebSocket status returned when the peer has closed
 75 | 	// its connection.
 76 | 	ClosePeerHungUp
 77 | 
 78 | 	// CloseBadKey is the WebSocket status returned when the peer has closed its
 79 | 	// connection because the key it derived is bad.
 80 | 	CloseBadKey
 81 | 
 82 | 	// CloseWebRTCSuccess indicates a WebRTC connection was successful.
 83 | 	CloseWebRTCSuccess
 84 | 
 85 | 	// CloseWebRTCSuccessDirect indicates a WebRTC connection was successful and we
 86 | 	// know it's peer-to-peer.
 87 | 	CloseWebRTCSuccessDirect
 88 | 
 89 | 	// CloseWebRTCSuccessRelay indicates a WebRTC connection was successful and we
 90 | 	// know it's going via a relay.
 91 | 	CloseWebRTCSuccessRelay
 92 | 
 93 | 	// CloseWebRTCFailed we couldn't establish a WebRTC connection.
 94 | 	CloseWebRTCFailed
 95 | )
 96 | 
 97 | var (
 98 | 	// ErrBadVersion is returned when the signalling server runs an incompatible
 99 | 	// version of the signalling protocol.
100 | 	ErrBadVersion = errors.New("bad version")
101 | 
102 | 	// ErrBadVersion is returned when the the peer on the same slot uses a different
103 | 	// password.
104 | 	ErrBadKey = errors.New("bad key")
105 | 
106 | 	// ErrNoSuchSlot indicates no one is on the slot requested.
107 | 	ErrNoSuchSlot = errors.New("no such slot")
108 | 
109 | 	// ErrTimedOut indicates signalling has timed out.
110 | 	ErrTimedOut = errors.New("timed out")
111 | )
112 | 
113 | // Verbose logging.
114 | var Verbose = false
115 | 
116 | func logf(format string, v ...interface{}) {
117 | 	if Verbose {
118 | 		log.Printf(format, v...)
119 | 	}
120 | }
121 | 
122 | // A Wormhole is a WebRTC connection established via the WebWormhole signalling
123 | // protocol. It is wraps webrtc.PeerConnection and webrtc.DataChannel.
124 | //
125 | // BUG(s): A PeerConnection established via Wormhole will always have a DataChannel
126 | // created for it, with the name "data" and id 0.
127 | type Wormhole struct {
128 | 	rwc io.ReadWriteCloser
129 | 	d   *webrtc.DataChannel
130 | 	pc  *webrtc.PeerConnection
131 | 
132 | 	// opened signals that the underlying DataChannel is open and ready
133 | 	// to handle data.
134 | 	opened chan struct{}
135 | 	// err forwards errors from the OnError callback.
136 | 	err chan error
137 | 	// flushc is a condition variable to coordinate flushed state of the
138 | 	// underlying channel.
139 | 	flushc *sync.Cond
140 | }
141 | 
142 | // Read writes a message to the default DataChannel.
143 | func (c *Wormhole) Write(p []byte) (n int, err error) {
144 | 	// The webrtc package's channel does not have a blocking Write, so
145 | 	// we can't just use io.Copy until the issue is fixed upsteam.
146 | 	// Work around this by blocking here and waiting for flushes.
147 | 	// https://github.com/pion/sctp/issues/77
148 | 	c.flushc.L.Lock()
149 | 	for c.d.BufferedAmount() > c.d.BufferedAmountLowThreshold() {
150 | 		c.flushc.Wait()
151 | 	}
152 | 	c.flushc.L.Unlock()
153 | 	return c.rwc.Write(p)
154 | }
155 | 
156 | // Read read a message from the default DataChannel.
157 | func (c *Wormhole) Read(p []byte) (n int, err error) {
158 | 	return c.rwc.Read(p)
159 | }
160 | 
161 | // TODO benchmark this buffer madness.
162 | func (c *Wormhole) flushed() {
163 | 	c.flushc.L.Lock()
164 | 	c.flushc.Signal()
165 | 	c.flushc.L.Unlock()
166 | }
167 | 
168 | // Close attempts to flush the DataChannel buffers then close it
169 | // and its PeerConnection.
170 | func (c *Wormhole) Close() (err error) {
171 | 	logf("closing")
172 | 	for c.d.BufferedAmount() != 0 {
173 | 		// SetBufferedAmountLowThreshold does not seem to take effect
174 | 		// when after the last Write().
175 | 		time.Sleep(time.Second) // eww.
176 | 	}
177 | 	tryclose := func(c io.Closer) {
178 | 		e := c.Close()
179 | 		if e != nil {
180 | 			err = e
181 | 		}
182 | 	}
183 | 	defer tryclose(c.pc)
184 | 	defer tryclose(c.d)
185 | 	defer tryclose(c.rwc)
186 | 	return nil
187 | }
188 | 
189 | func (c *Wormhole) open() {
190 | 	var err error
191 | 	c.rwc, err = c.d.Detach()
192 | 	if err != nil {
193 | 		c.err <- err
194 | 		return
195 | 	}
196 | 	close(c.opened)
197 | }
198 | 
199 | // It's not really clear to me when this will be invoked.
200 | func (c *Wormhole) error(err error) {
201 | 	log.Printf("debug: %v", err)
202 | 	c.err <- err
203 | }
204 | 
205 | func readEncJSON(ws *websocket.Conn, key *[32]byte, v interface{}) error {
206 | 	_, buf, err := ws.Read(context.TODO())
207 | 	if err != nil {
208 | 		return err
209 | 	}
210 | 	encrypted, err := base64.URLEncoding.DecodeString(string(buf))
211 | 	if err != nil {
212 | 		return err
213 | 	}
214 | 	var nonce [24]byte
215 | 	copy(nonce[:], encrypted[:24])
216 | 	jsonmsg, ok := secretbox.Open(nil, encrypted[24:], &nonce, key)
217 | 	if !ok {
218 | 		return ErrBadKey
219 | 	}
220 | 	return json.Unmarshal(jsonmsg, v)
221 | }
222 | 
223 | func writeEncJSON(ws *websocket.Conn, key *[32]byte, v interface{}) error {
224 | 	jsonmsg, err := json.Marshal(v)
225 | 	if err != nil {
226 | 		return err
227 | 	}
228 | 	var nonce [24]byte
229 | 	if _, err := io.ReadFull(crand.Reader, nonce[:]); err != nil {
230 | 		return err
231 | 	}
232 | 	return ws.Write(
233 | 		context.TODO(),
234 | 		websocket.MessageText,
235 | 		[]byte(base64.URLEncoding.EncodeToString(
236 | 			secretbox.Seal(nonce[:], jsonmsg, &nonce, key),
237 | 		)),
238 | 	)
239 | }
240 | 
241 | func readBase64(ws *websocket.Conn) ([]byte, error) {
242 | 	_, buf, err := ws.Read(context.TODO())
243 | 	if err != nil {
244 | 		return nil, err
245 | 	}
246 | 	return base64.URLEncoding.DecodeString(string(buf))
247 | }
248 | 
249 | func writeBase64(ws *websocket.Conn, p []byte) error {
250 | 	return ws.Write(
251 | 		context.TODO(),
252 | 		websocket.MessageText,
253 | 		[]byte(base64.URLEncoding.EncodeToString(p)),
254 | 	)
255 | }
256 | 
257 | // readInitMsg reads the first message the signalling server sends over
258 | // the WebSocket connection, which has metadata includign assigned slot
259 | // and ICE servers to use.
260 | func readInitMsg(ws *websocket.Conn) (slot string, iceServers []webrtc.ICEServer, err error) {
261 | 	msg := struct {
262 | 		Slot       string             `json:"slot",omitempty`
263 | 		ICEServers []webrtc.ICEServer `json:"iceServers",omitempty`
264 | 	}{}
265 | 
266 | 	_, buf, err := ws.Read(context.TODO())
267 | 	if err != nil {
268 | 		return "", nil, err
269 | 	}
270 | 	err = json.Unmarshal(buf, &msg)
271 | 	return msg.Slot, msg.ICEServers, err
272 | }
273 | 
274 | // handleRemoteCandidates waits for remote candidate to trickle in. We close
275 | // the websocket when we get a successful connection so this should fail and
276 | // exit at some point.
277 | func (c *Wormhole) handleRemoteCandidates(ws *websocket.Conn, key *[32]byte) {
278 | 	for {
279 | 		var candidate webrtc.ICECandidateInit
280 | 		err := readEncJSON(ws, key, &candidate)
281 | 		if websocket.CloseStatus(err) == websocket.StatusNormalClosure {
282 | 			return
283 | 		}
284 | 		if err != nil {
285 | 			logf("cannot read remote candidate: %v", err)
286 | 			return
287 | 		}
288 | 		logf("received new remote candidate: %v", candidate.Candidate)
289 | 		err = c.pc.AddICECandidate(candidate)
290 | 		if err != nil {
291 | 			logf("cannot add candidate: %v", err)
292 | 			return
293 | 		}
294 | 	}
295 | }
296 | 
297 | func (c *Wormhole) newPeerConnection(ice []webrtc.ICEServer) error {
298 | 	// Accessing pion/webrtc APIs like DataChannel.Detach() requires
299 | 	// that we do this voodoo.
300 | 	s := webrtc.SettingEngine{}
301 | 	s.DetachDataChannels()
302 | 	s.SetICEProxyDialer(proxy.FromEnvironment())
303 | 	rtcapi := webrtc.NewAPI(webrtc.WithSettingEngine(s))
304 | 
305 | 	var err error
306 | 	c.pc, err = rtcapi.NewPeerConnection(webrtc.Configuration{
307 | 		ICEServers: ice,
308 | 	})
309 | 	if err != nil {
310 | 		return err
311 | 	}
312 | 
313 | 	sigh := true
314 | 	c.d, err = c.pc.CreateDataChannel("data", &webrtc.DataChannelInit{
315 | 		Negotiated: &sigh,
316 | 		ID:         new(uint16),
317 | 	})
318 | 	if err != nil {
319 | 		return err
320 | 	}
321 | 	c.d.OnOpen(c.open)
322 | 	c.d.OnError(c.error)
323 | 	c.d.OnBufferedAmountLow(c.flushed)
324 | 	// Any threshold amount >= 1MiB seems to occasionally lock up pion.
325 | 	// Choose 512 KiB as a safe default.
326 | 	c.d.SetBufferedAmountLowThreshold(512 << 10)
327 | 	return nil
328 | }
329 | 
330 | // IsRelay returns whether this connection is over a TURN relay or not.
331 | func (c *Wormhole) IsRelay() bool {
332 | 	stats := c.pc.GetStats()
333 | 	for _, s := range stats {
334 | 		pairstats, ok := s.(webrtc.ICECandidatePairStats)
335 | 		if !ok {
336 | 			continue
337 | 		}
338 | 		if !pairstats.Nominated {
339 | 			continue
340 | 		}
341 | 		local, ok := stats[pairstats.LocalCandidateID].(webrtc.ICECandidateStats)
342 | 		if !ok {
343 | 			continue
344 | 		}
345 | 		remote, ok := stats[pairstats.RemoteCandidateID].(webrtc.ICECandidateStats)
346 | 		if !ok {
347 | 			continue
348 | 		}
349 | 		if remote.CandidateType == webrtc.ICECandidateTypeRelay ||
350 | 			local.CandidateType == webrtc.ICECandidateTypeRelay {
351 | 			return true
352 | 		}
353 | 	}
354 | 	return false
355 | }
356 | 
357 | // New starts a new signalling handshake after asking the server to allocate
358 | // a new slot.
359 | //
360 | // The slot is used to synchronise with the remote peer on signalling server
361 | // sigserv, and pass is used as the PAKE password authenticate the WebRTC
362 | // offer and answer.
363 | //
364 | // The server generated slot identifier is written on slotc.
365 | //
366 | // If pc is nil it initialises ones using the default STUN server.
367 | func New(pass string, sigserv string, slotc chan string) (*Wormhole, error) {
368 | 	c := &Wormhole{
369 | 		opened: make(chan struct{}),
370 | 		err:    make(chan error),
371 | 		flushc: sync.NewCond(&sync.Mutex{}),
372 | 	}
373 | 
374 | 	u, err := url.Parse(sigserv)
375 | 	if err != nil {
376 | 		return nil, err
377 | 	}
378 | 	if u.Scheme == "http" || u.Scheme == "ws" {
379 | 		u.Scheme = "ws"
380 | 	} else {
381 | 		u.Scheme = "wss"
382 | 	}
383 | 	wsaddr := u.String()
384 | 
385 | 	ws, _, err := websocket.Dial(context.TODO(), wsaddr, &websocket.DialOptions{
386 | 		Subprotocols: []string{Protocol},
387 | 	})
388 | 	if err != nil {
389 | 		return nil, err
390 | 	}
391 | 
392 | 	assignedSlot, iceServers, err := readInitMsg(ws)
393 | 	if websocket.CloseStatus(err) == CloseWrongProto {
394 | 		return nil, ErrBadVersion
395 | 	}
396 | 	if err != nil {
397 | 		return nil, err
398 | 	}
399 | 	logf("connected to signalling server, got slot: %v", assignedSlot)
400 | 	slotc <- assignedSlot
401 | 	err = c.newPeerConnection(iceServers)
402 | 	if err != nil {
403 | 		return nil, err
404 | 	}
405 | 
406 | 	msgA, err := readBase64(ws)
407 | 	if err != nil {
408 | 		return nil, err
409 | 	}
410 | 	logf("got A pake msg (%v bytes)", len(msgA))
411 | 
412 | 	msgB, mk, err := cpace.Exchange(pass, cpace.NewContextInfo("", "", nil), msgA)
413 | 	if err != nil {
414 | 		return nil, err
415 | 	}
416 | 	key := [32]byte{}
417 | 	_, err = io.ReadFull(hkdf.New(sha256.New, mk, nil, nil), key[:])
418 | 	if err != nil {
419 | 		return nil, err
420 | 	}
421 | 	err = writeBase64(ws, msgB)
422 | 	if err != nil {
423 | 		return nil, err
424 | 	}
425 | 	logf("have key, sent B pake msg (%v bytes)", len(msgB))
426 | 
427 | 	c.pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
428 | 		if candidate == nil {
429 | 			return
430 | 		}
431 | 		err := writeEncJSON(ws, &key, candidate.ToJSON())
432 | 		if websocket.CloseStatus(err) == websocket.StatusNormalClosure {
433 | 			return
434 | 		}
435 | 		if err != nil {
436 | 			logf("cannot send local candidate: %v", err)
437 | 			return
438 | 		}
439 | 		logf("sent new local candidate: %v", candidate.String())
440 | 	})
441 | 
442 | 	offer, err := c.pc.CreateOffer(nil)
443 | 	if err != nil {
444 | 		return nil, err
445 | 	}
446 | 	err = writeEncJSON(ws, &key, offer)
447 | 	if err != nil {
448 | 		return nil, err
449 | 	}
450 | 	err = c.pc.SetLocalDescription(offer)
451 | 	if err != nil {
452 | 		return nil, err
453 | 	}
454 | 	logf("sent offer")
455 | 
456 | 	var answer webrtc.SessionDescription
457 | 	err = readEncJSON(ws, &key, &answer)
458 | 	if websocket.CloseStatus(err) == CloseBadKey {
459 | 		return nil, ErrBadKey
460 | 	}
461 | 	if err != nil {
462 | 		return nil, err
463 | 	}
464 | 	err = c.pc.SetRemoteDescription(answer)
465 | 	if err != nil {
466 | 		return nil, err
467 | 	}
468 | 	logf("got answer")
469 | 
470 | 	go c.handleRemoteCandidates(ws, &key)
471 | 
472 | 	select {
473 | 	case <-c.opened:
474 | 		relay := c.IsRelay()
475 | 		logf("webrtc connection succeeded (relay: %v) closing signalling channel", relay)
476 | 		if relay {
477 | 			ws.Close(CloseWebRTCSuccessRelay, "")
478 | 		} else {
479 | 			ws.Close(CloseWebRTCSuccessDirect, "")
480 | 		}
481 | 	case err = <-c.err:
482 | 		ws.Close(CloseWebRTCFailed, "")
483 | 	case <-time.After(30 * time.Second):
484 | 		err = ErrTimedOut
485 | 		ws.Close(CloseWebRTCFailed, "timed out")
486 | 	}
487 | 	return c, err
488 | }
489 | 
490 | // Join performs the signalling handshake to join an existing slot.
491 | //
492 | // slot is used to synchronise with the remote peer on signalling server
493 | // sigserv, and pass is used as the PAKE password authenticate the WebRTC
494 | // offer and answer.
495 | //
496 | // If pc is nil it initialises ones using the default STUN server.
497 | func Join(slot, pass string, sigserv string) (*Wormhole, error) {
498 | 	c := &Wormhole{
499 | 		opened: make(chan struct{}),
500 | 		err:    make(chan error),
501 | 		flushc: sync.NewCond(&sync.Mutex{}),
502 | 	}
503 | 
504 | 	u, err := url.Parse(sigserv)
505 | 	if err != nil {
506 | 		return nil, err
507 | 	}
508 | 	if u.Scheme == "http" || u.Scheme == "ws" {
509 | 		u.Scheme = "ws"
510 | 	} else {
511 | 		u.Scheme = "wss"
512 | 	}
513 | 	u.Path += slot
514 | 	wsaddr := u.String()
515 | 
516 | 	// Start the handshake.
517 | 	ws, _, err := websocket.Dial(context.TODO(), wsaddr, &websocket.DialOptions{
518 | 		Subprotocols: []string{Protocol},
519 | 	})
520 | 	if err != nil {
521 | 		return nil, err
522 | 	}
523 | 
524 | 	_, iceServers, err := readInitMsg(ws)
525 | 	if websocket.CloseStatus(err) == CloseWrongProto {
526 | 		return nil, ErrBadVersion
527 | 	}
528 | 	if err != nil {
529 | 		return nil, err
530 | 	}
531 | 	logf("connected to signalling server on slot: %v", slot)
532 | 	err = c.newPeerConnection(iceServers)
533 | 	if err != nil {
534 | 		return nil, err
535 | 	}
536 | 
537 | 	// The identity arguments are to bind endpoint identities in PAKE. Cf. Unknown
538 | 	// Key-Share Attack. https://tools.ietf.org/html/draft-ietf-mmusic-sdp-uks-03
539 | 	//
540 | 	// In the context of a program like magic-wormhole we do not have ahead of time
541 | 	// information on the identity of the remote party. We only have the slot name,
542 | 	// and sometimes even that at this stage. But that's okay, since:
543 | 	//   a) The password is randomly generated and ephemeral.
544 | 	//   b) A peer only gets one guess.
545 | 	// An unintended destination is likely going to fail PAKE.
546 | 
547 | 	msgA, pake, err := cpace.Start(pass, cpace.NewContextInfo("", "", nil))
548 | 	if err != nil {
549 | 		return nil, err
550 | 	}
551 | 	err = writeBase64(ws, msgA)
552 | 	if err != nil {
553 | 		return nil, err
554 | 	}
555 | 	logf("sent A pake msg (%v bytes)", len(msgA))
556 | 
557 | 	msgB, err := readBase64(ws)
558 | 	if websocket.CloseStatus(err) == CloseWrongProto {
559 | 		return nil, ErrBadVersion
560 | 	}
561 | 	if err != nil {
562 | 		return nil, err
563 | 	}
564 | 	mk, err := pake.Finish(msgB)
565 | 	if err != nil {
566 | 		return nil, err
567 | 	}
568 | 	key := [32]byte{}
569 | 	_, err = io.ReadFull(hkdf.New(sha256.New, mk, nil, nil), key[:])
570 | 	if err != nil {
571 | 		return nil, err
572 | 	}
573 | 	logf("have key, got B msg (%v bytes)", len(msgB))
574 | 
575 | 	var offer webrtc.SessionDescription
576 | 	err = readEncJSON(ws, &key, &offer)
577 | 	if err == ErrBadKey {
578 | 		// Close with the right status so the other side knows to quit immediately.
579 | 		ws.Close(CloseBadKey, "bad key")
580 | 		return nil, err
581 | 	}
582 | 	if err != nil {
583 | 		return nil, err
584 | 	}
585 | 
586 | 	c.pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
587 | 		if candidate == nil {
588 | 			return
589 | 		}
590 | 		err := writeEncJSON(ws, &key, candidate.ToJSON())
591 | 		if websocket.CloseStatus(err) == websocket.StatusNormalClosure {
592 | 			return
593 | 		}
594 | 		if err != nil {
595 | 			logf("cannot send local candidate: %v", err)
596 | 			return
597 | 		}
598 | 		logf("sent new local candidate: %v", candidate.String())
599 | 	})
600 | 
601 | 	err = c.pc.SetRemoteDescription(offer)
602 | 	if err != nil {
603 | 		return nil, err
604 | 	}
605 | 	logf("got offer")
606 | 	answer, err := c.pc.CreateAnswer(nil)
607 | 	if err != nil {
608 | 		return nil, err
609 | 	}
610 | 	err = writeEncJSON(ws, &key, answer)
611 | 	if err != nil {
612 | 		return nil, err
613 | 	}
614 | 	err = c.pc.SetLocalDescription(answer)
615 | 	if err != nil {
616 | 		return nil, err
617 | 	}
618 | 	logf("sent answer")
619 | 
620 | 	go c.handleRemoteCandidates(ws, &key)
621 | 
622 | 	select {
623 | 	case <-c.opened:
624 | 		relay := c.IsRelay()
625 | 		logf("webrtc connection succeeded (relay: %v) closing signalling channel", relay)
626 | 		if relay {
627 | 			ws.Close(CloseWebRTCSuccessRelay, "")
628 | 		} else {
629 | 			ws.Close(CloseWebRTCSuccessDirect, "")
630 | 		}
631 | 	case err = <-c.err:
632 | 		ws.Close(CloseWebRTCFailed, "")
633 | 	case <-time.After(30 * time.Second):
634 | 		err = ErrTimedOut
635 | 		ws.Close(CloseWebRTCFailed, "timed out")
636 | 	}
637 | 	return c, err
638 | }
639 | 


--------------------------------------------------------------------------------