sendnrw/netbird
2
0
Fork 0
mirror of https://github.com/netbirdio/netbird.git synced 2026-10-08 22:49:10 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: add webrtc bind base

Browse Source
This commit is contained in:
braginini
2021-11-04 08:43:52 +01:00
parent c9b5a0e5fd
commit f71a46d27d
10 changed files with 298 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files
browser/Makefile
+3
View File
@@ -0,0 +1,3 @@
run:
GOOS=js GOARCH=wasm go build -o assets/tun.wasm ./wasm/
go run main.go
browser/assets/index.html
-1
View File
@@ -28,7 +28,6 @@
<label for="peerAllowedIPs">Wireguard Peer AllowedIPs:</label>
<input id="peerAllowedIPs" type=input size="50" value="Paste other peer AllowedIPs">
<p/>
<!--<input type=button value="wgPrivateKey" onclick='wgPrivateKey(prompt("Wireguard Private Key", ""))'>-->
<input type=button value="start" onclick='connect()'>
</form>
</body>
browser/assets/tun.wasm
BIN
View File
Binary file not shown.
browser/client/client.go
+39
View File
@@ -0,0 +1,39 @@
package main
import (
"encoding/hex"
"fmt"
conn2 "golang.zx2c4.com/wireguard/conn"
"golang.zx2c4.com/wireguard/device"
"golang.zx2c4.com/wireguard/tun/netstack"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
"net"
)
func main() {
tun, _, err := netstack.CreateNetTUN(
[]net.IP{net.ParseIP("10.100.0.2")},
[]net.IP{net.ParseIP("8.8.8.8")},
1420)
if err != nil {
return
}
clientKey, _ := wgtypes.ParseKey("WI+uoQD9jGi+nyifmFwmswQu5r0uWFH31WeSmfU0snI=")
serverKey, _ := wgtypes.ParseKey("kLpbgt+g2+g8x556VmsLYyhTh77WmKfaFB0x+LcVyWY=")
publicServerkey := serverKey.PublicKey()
dev := device.NewDevice(tun, conn2.NewStdNetBind(), device.NewLogger(device.LogLevelVerbose, ""))
err = dev.IpcSet(fmt.Sprintf("private_key=%s\npublic_key=%s\npersistent_keepalive_interval=5\nendpoint=65.108.52.126:50000\nallowed_ip=0.0.0.0/0",
hex.EncodeToString(clientKey[:]),
hex.EncodeToString(publicServerkey[:]),
))
if err != nil {
return
}
select {}
}
browser/conn/bind_webrtc.go
+51
View File
@@ -0,0 +1,51 @@
package conn
import "net"
import "golang.zx2c4.com/wireguard/conn"
// WebRTCBind is an implementation of Wireguard Bind interface backed by WebRTC data channel
type WebRTCBind struct {
}
func (*WebRTCBind) Open(port uint16) (fns []conn.ReceiveFunc, actualPort uint16, err error) {
return nil, 0, nil
}
func (*WebRTCBind) Close() error {
return nil
}
func (*WebRTCBind) SetMark(mark uint32) error {
return nil
}
func (*WebRTCBind) Send(b []byte, ep conn.Endpoint) error {
return nil
}
func (*WebRTCBind) ParseEndpoint(s string) (conn.Endpoint, error) {
return nil, nil
}
// WebRTCEndpoint is an implementation of Wireguard's Endpoint interface backed by WebRTC
type WebRTCEndpoint struct {
}
func (*WebRTCEndpoint) ClearSrc() {
}
func (*WebRTCEndpoint) SrcToString() string {
return ""
}
func (*WebRTCEndpoint) DstToString() string {
return ""
}
func (*WebRTCEndpoint) DstToBytes() []byte {
return nil
}
func (*WebRTCEndpoint) DstIP() net.IP {
return nil
}
func (*WebRTCEndpoint) SrcIP() net.IP {
return nil
}
browser/main.go
+7 -151
View File
@@ -1,162 +1,18 @@
package main
import (
"context"
"github.com/wiretrustee/wiretrustee/signal/client"
"github.com/wiretrustee/wiretrustee/signal/proto"
"time"
/* "context"
"github.com/wiretrustee/wiretrustee/signal/client"
"github.com/wiretrustee/wiretrustee/signal/proto"*/
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
"fmt"
"log"
"syscall/js"
/* "time"*/)
"net/http"
)
func main() {
log.Print("listening on http://localhost:9090")
err := http.ListenAndServe(":9090", http.FileServer(http.Dir("./assets")))
//err := http.ListenAndServe(":9090", http.FileServer(http.Dir("/home/braginini/Documents/projects/my/wiretrustee/rtctunnel/examples/browser-http/dist")))
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer cancel()
connectToSignal := func(key wgtypes.Key, remoteKey wgtypes.Key) {
signalClient, err := client.NewWebsocketClient(ctx, "ws://localhost:80/signal", key)
if err != nil {
return
}
log.Printf("connected to signal")
go func() {
signalClient.Receive(func(msg *proto.Message) error {
log.Printf("received a message from %v -> %v", msg.RemoteKey, msg.Body.Payload)
return nil
})
}()
time.Sleep(5 * time.Second)
log.Printf("sending msg to signal")
err = signalClient.Send(&proto.Message{
Key: key.PublicKey().String(),
RemoteKey: remoteKey.String(),
Body: &proto.Body{
Type: 0,
Payload: "hello",
},
})
if err != nil {
return
}
}
js.Global().Set("generateWireguardKey", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
key, err := wgtypes.GenerateKey()
if err != nil {
return nil
}
js.Global().Get("document").Call("getElementById", "wgPrivateKey").Set("value", key.String())
log.Printf("Wireguard Public key %s", key.PublicKey().String())
js.Global().Get("document").Call("getElementById", "publicKey").Set("value", key.PublicKey().String())
return nil
}))
js.Global().Set("connect", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
wgPrivateKey := js.Global().Get("document").Call("getElementById", "wgPrivateKey").Get("value").String()
key, err := wgtypes.ParseKey(wgPrivateKey)
if err != nil {
return err
}
remotePublicKey := js.Global().Get("document").Call("getElementById", "peerKey").Get("value").String()
remoteKey, err := wgtypes.ParseKey(remotePublicKey)
if err != nil {
return err
}
log.Printf("Remote Wireguard Public key %s", remoteKey.String())
log.Printf("Our Wireguard Public key %s", key.PublicKey().String())
go connectToSignal(key, remoteKey)
return nil
}))
select {}
/*tun, tnet, err := netstack.CreateNetTUN(
[]net.IP{net.ParseIP("10.100.0.2")},
[]net.IP{net.ParseIP("8.8.8.8")},
1420)
if err != nil {
log.Panic(err)
}
log.Println("1")
clientKey,_ := wgtypes.ParseKey("WI+uoQD9jGi+nyifmFwmswQu5r0uWFH31WeSmfU0snI=")
serverKey,_ := wgtypes.ParseKey("kLpbgt+g2+g8x556VmsLYyhTh77WmKfaFB0x+LcVyWY=")
publicServerkey := serverKey.PublicKey()
log.Println("2")*/
/*/*stunURL, err := ice.ParseURL("stun:stun.wiretrustee.com:5555")
if err != nil {
log.Panic(err)
}
agent, err := ice.NewAgent(&ice.AgentConfig{
NetworkTypes: []ice.NetworkType{ice.NetworkTypeUDP4},
Urls: []*ice.URL{stunURL},
CandidateTypes: []ice.CandidateType{ice.CandidateTypeHost, ice.CandidateTypeServerReflexive, ice.CandidateTypeRelay},
})
if err != nil {
log.Panic(err)
}*/
/*sig, err := signal.NewClient(context.Background(), "localhost:10000", clientKey, false)
if err != nil {
log.Printf("%v", err)
fmt.Println("Failed to start server", err)
return
}
sig.Receive(func(msg *proto.Message) error {
log.Printf("%v", msg)
return nil
})
sig.WaitConnected()
log.Println("3")
dev := device.NewDevice(tun, conn.NewDefaultBind(), device.NewLogger(device.LogLevelVerbose, ""))
err = dev.IpcSet(fmt.Sprintf("private_key=%s\npublic_key=%s\npersistent_keepalive_interval=5\nendpoint=65.108.52.126:50000\nallowed_ip=0.0.0.0/0",
hex.EncodeToString(clientKey[:]),
hex.EncodeToString(publicServerkey[:]),
))
log.Println("4")
if err != nil {
log.Panic(err)
}
err = dev.Up()
if err != nil {
log.Panic(err)
}
client := http.Client{
Transport: &http.Transport{
DialContext: tnet.DialContext,
},
}
resp, err := client.Get("https://www.zx2c4.com/ip")
if err != nil {
log.Panic(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Panic(err)
}
log.Println(string(body))
time.Sleep(30 * time.Second)*/
}
browser/server/main.go
-18
View File
@@ -1,18 +0,0 @@
package main
import (
"fmt"
"log"
"net/http"
)
func main() {
log.Print("listening on http://localhost:9090")
err := http.ListenAndServe(":9090", http.FileServer(http.Dir("/home/braginini/Documents/projects/my/wiretrustee/wiretrustee/browser/assets")))
//err := http.ListenAndServe(":9090", http.FileServer(http.Dir("/home/braginini/Documents/projects/my/wiretrustee/rtctunnel/examples/browser-http/dist")))
if err != nil {
fmt.Println("Failed to start server", err)
return
}
}
browser/wasm/client_js.go
+190
View File
@@ -0,0 +1,190 @@
package main
import (
"context"
"encoding/hex"
"fmt"
"github.com/wiretrustee/wiretrustee/browser/conn"
"github.com/wiretrustee/wiretrustee/signal/client"
"github.com/wiretrustee/wiretrustee/signal/proto"
"golang.zx2c4.com/wireguard/device"
"golang.zx2c4.com/wireguard/tun/netstack"
"net"
"time"
/* "context"
"github.com/wiretrustee/wiretrustee/signal/client"
"github.com/wiretrustee/wiretrustee/signal/proto"*/
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
"log"
"syscall/js"
/* "time"*/)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer cancel()
connectToSignal := func(key wgtypes.Key, remoteKey wgtypes.Key) {
signalClient, err := client.NewWebsocketClient(ctx, "ws://localhost:80/signal", key)
if err != nil {
return
}
log.Printf("connected to signal")
go func() {
signalClient.Receive(func(msg *proto.Message) error {
log.Printf("received a message from %v -> %v", msg.RemoteKey, msg.Body.Payload)
return nil
})
}()
time.Sleep(5 * time.Second)
tun, _, err := netstack.CreateNetTUN(
[]net.IP{net.ParseIP("10.100.0.2")},
[]net.IP{net.ParseIP("8.8.8.8")},
1420)
dev := device.NewDevice(tun, &conn.WebRTCBind{}, device.NewLogger(device.LogLevelVerbose, ""))
err = dev.IpcSet(fmt.Sprintf("private_key=%s\npublic_key=%s\npersistent_keepalive_interval=5\nendpoint=65.108.52.126:50000\nallowed_ip=0.0.0.0/0",
hex.EncodeToString(key[:]),
hex.EncodeToString(remoteKey[:]),
))
log.Println("4")
if err != nil {
log.Panic(err)
}
err = dev.Up()
if err != nil {
log.Panic(err)
}
log.Printf("device started")
/*stunURL, err := ice.ParseURL("stun:stun.wiretrustee.com:5555")
if err != nil {
log.Panic(err)
}
agent, err := ice.NewAgent(&ice.AgentConfig{
Urls: []*ice.URL{stunURL},
CandidateTypes: []ice.CandidateType{ice.CandidateTypeHost, ice.CandidateTypeServerReflexive, ice.CandidateTypeRelay},
})
fmt.Println(agent)
err = agent.OnCandidate(func(candidate ice.Candidate) {
fmt.Printf("gathered candidate %s", cancel)
})
if err != nil {
return
}
fmt.Println("started gathering candidates")*/
select {}
/*log.Printf("sending msg to signal")
err = signalClient.Send(&proto.Message{
Key: key.PublicKey().String(),
RemoteKey: remoteKey.String(),
Body: &proto.Body{
Type: 0,
Payload: "hello",
},
})
if err != nil {
return
}*/
}
js.Global().Set("generateWireguardKey", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
key, err := wgtypes.GenerateKey()
if err != nil {
return nil
}
js.Global().Get("document").Call("getElementById", "wgPrivateKey").Set("value", key.String())
log.Printf("Wireguard Public key %s", key.PublicKey().String())
js.Global().Get("document").Call("getElementById", "publicKey").Set("value", key.PublicKey().String())
return nil
}))
js.Global().Set("connect", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
wgPrivateKey := js.Global().Get("document").Call("getElementById", "wgPrivateKey").Get("value").String()
key, err := wgtypes.ParseKey(wgPrivateKey)
if err != nil {
return err
}
remotePublicKey := js.Global().Get("document").Call("getElementById", "peerKey").Get("value").String()
remoteKey, err := wgtypes.ParseKey(remotePublicKey)
if err != nil {
return err
}
log.Printf("Remote Wireguard Public key %s", remoteKey.String())
log.Printf("Our Wireguard Public key %s", key.PublicKey().String())
go connectToSignal(key, remoteKey)
return nil
}))
select {}
/*tun, tnet, err := netstack.CreateNetTUN(
[]net.IP{net.ParseIP("10.100.0.2")},
[]net.IP{net.ParseIP("8.8.8.8")},
1420)
if err != nil {
log.Panic(err)
}
log.Println("1")
clientKey,_ := wgtypes.ParseKey("WI+uoQD9jGi+nyifmFwmswQu5r0uWFH31WeSmfU0snI=")
serverKey,_ := wgtypes.ParseKey("kLpbgt+g2+g8x556VmsLYyhTh77WmKfaFB0x+LcVyWY=")
publicServerkey := serverKey.PublicKey()
log.Println("2")*/
/*/*
dev := device.NewDevice(tun, conn.NewDefaultBind(), device.NewLogger(device.LogLevelVerbose, ""))
err = dev.IpcSet(fmt.Sprintf("private_key=%s\npublic_key=%s\npersistent_keepalive_interval=5\nendpoint=65.108.52.126:50000\nallowed_ip=0.0.0.0/0",
hex.EncodeToString(clientKey[:]),
hex.EncodeToString(publicServerkey[:]),
))
log.Println("4")
if err != nil {
log.Panic(err)
}
err = dev.Up()
if err != nil {
log.Panic(err)
}
client := http.Client{
Transport: &http.Transport{
DialContext: tnet.DialContext,
},
}
resp, err := client.Get("https://www.zx2c4.com/ip")
if err != nil {
log.Panic(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Panic(err)
}
log.Println(string(body))
time.Sleep(30 * time.Second)*/
}