update

src/croc/croc.go

@@ -135,19 +135,19 @@ func New(ops Options) (c *Client, err error) {
 		log.SetLevel("info")
 	}
 
-	// initialize pake
-	if c.Options.IsSender {
-		c.Pake, err = pake.Init([]byte(c.Options.SharedSecret), 1, elliptic.P521(), 1*time.Microsecond)
-	} else {
-		c.Pake, err = pake.Init([]byte(c.Options.SharedSecret), 0, elliptic.P521(), 1*time.Microsecond)
-	}
+	// connect to relay and determine
+	// whether it is receiver or offerer
+	err = c.connectToRelay()
 	if err != nil {
 		return
 	}
 
-	// connect to relay and determine
-	// whether it is receiver or offerer
-	err = c.connectToRelay()
+	// initialize pake
+	if c.IsOfferer {
+		c.Pake, err = pake.Init([]byte(c.Options.SharedSecret), 0, elliptic.P521(), 1*time.Microsecond)
+	} else {
+		c.Pake, err = pake.Init([]byte(c.Options.SharedSecret), 1, elliptic.P521(), 1*time.Microsecond)
+	}
 	if err != nil {
 		return
 	}
@@ -282,6 +282,7 @@ func (c *Client) getPAKE(keepSending bool) (err error) {
 		log.Error(err)
 		return
 	}
+	log.Debugf("getPake got: %+v", p)
 	err = c.Pake.Update(p.Payload)
 	if err != nil {
 		log.Error(err)
@@ -318,11 +319,10 @@ func (c *Client) connectToRelay() (err error) {
 	}
 
 	log.Debugf("connected and sending first message")
-	c.ws.WriteJSON(WebsocketMessage{
+	c.SendWebsocketMessage(WebsocketMessage{
 		Message: "offerer",
-	})
-	var wsmsg WebsocketMessage
-	err = c.ws.ReadJSON(&wsmsg)
+	}, false)
+	wsmsg, err := c.ReceiveWebsocketMessage(false)
 	if err != nil {
 		log.Debug("read:", err)
 		return

src/relay/relay.go

@@ -90,7 +90,7 @@ func (s *subscription) writePump() {
 				c.write(websocket.CloseMessage, []byte{})
 				return
 			}
-			if err := c.write(websocket.BinaryMessage, message); err != nil {
+			if err := c.write(websocket.TextMessage, message); err != nil {
 				return
 			}
 		case <-ticker.C:

src/webrtc/websend/index.html

@@ -116,18 +116,39 @@
 
         // websockets 
         var socket;
+        var pakeData;
+
+        var sendMessage = msg => {
+            log(`sending ${JSON.stringify(msg)}`)
+            socket.send(btoa(JSON.stringify(msg)));
+        }
 
         const socketMessageListener = (event) => {
-            log(event);
-            log(event.data);
-            var data = JSON.parse(event.data);
+            console.log(event.data);
+            var data;
+            if (event.data.includes("Message")) {
+                data = JSON.parse(event.data);
+            } else {
+                data = JSON.parse(atob(event.data));
+            }
             console.log(data);
+            if (data.Message == "pake") {
+                log("processing pake data");
+            } else if (data.Message == "offerer") {
+                log("offering the first pake");
+                pakeData = pakeInit("test1", 0);
+                console.log(pakeData);
+                sendMessage({
+                    "Message": "pake",
+                    "Payload": pakeData,
+                })
+            }
         };
         const socketOpenListener = (event) => {
             log('connected to websockets');
-            socket.send(JSON.stringify({
+            sendMessage({
                 "Message": "offerer",
-            }))
+            })
         }
         const socketCloseListener = (event) => {
             if (socket) {

src/webrtc/websend/main.go

@@ -199,7 +199,7 @@ func pakeInit(this js.Value, inputs []js.Value) interface{} {
 		return js.Global().Get("Error").New(err.Error())
 	}
 	bJSON, _ := json.Marshal(P)
-	return string(bJSON)
+	return base64.StdEncoding.EncodeToString(bJSON)
 }
 
 // pakeUpdate(pakeBytes,otherPublicPakeBytes)
@@ -208,19 +208,29 @@ func pakeUpdate(this js.Value, inputs []js.Value) interface{} {
 		return js.Global().Get("Error").New("need two input")
 	}
 	var P, Q *pake.Pake
-	err := json.Unmarshal([]byte(inputs[0].String()), &P)
+
+	b, err := base64.StdEncoding.DecodeString(inputs[0].String())
+	if err != nil {
+		return js.Global().Get("Error").New(err.Error())
+	}
+	err = json.Unmarshal(b, &P)
 	P.SetCurve(elliptic.P521())
 	if err != nil {
 		return js.Global().Get("Error").New(err.Error())
 	}
-	err = json.Unmarshal([]byte(inputs[1].String()), &Q)
+
+	b, err = base64.StdEncoding.DecodeString(inputs[1].String())
+	if err != nil {
+		return js.Global().Get("Error").New(err.Error())
+	}
+	err = json.Unmarshal(b, &Q)
 	Q.SetCurve(elliptic.P521())
 	if err != nil {
 		return js.Global().Get("Error").New(err.Error())
 	}
 	P.Update(Q.Bytes())
 	bJSON, _ := json.Marshal(P)
-	return string(bJSON)
+	return base64.StdEncoding.EncodeToString(bJSON)
 }
 
 // pakePublic(pakeBytes)
@@ -231,7 +241,7 @@ func pakePublic(this js.Value, inputs []js.Value) interface{} {
 	if err != nil {
 		return js.Global().Get("Error").New(err.Error())
 	}
-	return string(P.Public().Bytes())
+	return base64.StdEncoding.EncodeToString(P.Public().Bytes())
 }
 
 // pakeSessionKey(pakeBytes)
@@ -251,7 +261,7 @@ func pakeSessionKey(this js.Value, inputs []js.Value) interface{} {
 
 func main() {
 	c := make(chan bool)
-	fmt.Println("starting")
+	// fmt.Println("starting")
 	js.Global().Set("encrypt", js.FuncOf(encrypt))
 	js.Global().Set("decrypt", js.FuncOf(decrypt))
 	js.Global().Set("pakeInit", js.FuncOf(pakeInit))