1 files changed, 27 insertions, 13 deletions

diff --git a/src/gnunet/cmd/peer_mockup/main.go b/src/gnunet/cmd/peer_mockup/main.go
index 96f62da..4d29927 100644
--- a/src/gnunet/cmd/peer_mockup/main.go
+++ b/src/gnunet/cmd/peer_mockup/main.go
@@ -15,6 +15,7 @@ import (
         "gnunet/message"
         "gnunet/service"
 
+        "github.com/bfix/gospel/crypto/ed25519"
         "github.com/bfix/gospel/logger"
 )
 
@@ -33,10 +34,9 @@ var (
                 },
         }
         // configuration for remote node
-        remoteCfg  = "3GXXMNb5YpIUO7ejIR2Yy0Cf5texuLfDjHkXcqbPxkc="
-        remoteAddr = "udp://172.17.0.5:2086"
+        remoteCfg = "3GXXMNb5YpIUO7ejIR2Yy0Cf5texuLfDjHkXcqbPxkc="
 
-        // top-level variables used accross functions
+        // top-level variables used across functions
         local  *core.Peer // local peer (with private key)
         remote *core.Peer // remote peer
         c      *core.Core
@@ -79,7 +79,9 @@ func main() {
 
         if !asServer {
                 // we start the message exchange
-                c.Send(ctx, remote.GetID(), message.NewTransportTCPWelcomeMsg(c.PeerID()))
+                if err := c.Send(ctx, remote.GetID(), message.NewTransportTCPWelcomeMsg(c.PeerID())); err != nil {
+                        fmt.Printf("send message failed: %s", err.Error())
+                }
         }
 
         // handle OS signals
@@ -117,23 +119,27 @@ loop:
 // process incoming messages and send responses; it is used for protocol exploration only.
 // it tries to mimick the message flow between "real" GNUnet peers.
 func process(ctx context.Context, ev *core.Event) {
-
         logger.Printf(logger.DBG, "<<< %s", ev.Msg.String())
 
         switch msg := ev.Msg.(type) {
-
         case *message.TransportTCPWelcomeMsg:
-                c.Send(ctx, ev.Peer, message.NewTransportPingMsg(ev.Peer, nil))
+                if err := c.Send(ctx, ev.Peer, message.NewTransportPingMsg(ev.Peer, nil)); err != nil {
+                        logger.Printf(logger.ERROR, "TransportTCPWelcomeMsg send failed: %s", err.Error())
+                        return
+                }
 
         case *message.HelloMsg:
 
         case *message.TransportPingMsg:
                 mOut := message.NewTransportPongMsg(msg.Challenge, nil)
                 if err := mOut.Sign(local.PrvKey()); err != nil {
-                        logger.Println(logger.ERROR, "PONG: signing failed")
+                        logger.Printf(logger.ERROR, "PONG signing failed: %s", err.Error())
+                        return
+                }
+                if err := c.Send(ctx, ev.Peer, mOut); err != nil {
+                        logger.Printf(logger.ERROR, "TransportPongMsg send failed: %s", err.Error())
                         return
                 }
-                c.Send(ctx, ev.Peer, mOut)
                 logger.Printf(logger.DBG, ">>> %s", mOut)
 
         case *message.TransportPongMsg:
@@ -148,7 +154,9 @@ func process(ctx context.Context, ev *core.Event) {
         case *message.SessionSynMsg:
                 mOut := message.NewSessionSynAckMsg()
                 mOut.Timestamp = msg.Timestamp
-                c.Send(ctx, ev.Peer, mOut)
+                if err := c.Send(ctx, ev.Peer, mOut); err != nil {
+                        logger.Printf(logger.ERROR, "SessionSynAckMsg send failed: %s", err.Error())
+                }
                 logger.Printf(logger.DBG, ">>> %s", mOut)
 
         case *message.SessionQuotaMsg:
@@ -157,7 +165,9 @@ func process(ctx context.Context, ev *core.Event) {
 
         case *message.SessionKeepAliveMsg:
                 mOut := message.NewSessionKeepAliveRespMsg(msg.Nonce)
-                c.Send(ctx, ev.Peer, mOut)
+                if err := c.Send(ctx, ev.Peer, mOut); err != nil {
+                        logger.Printf(logger.ERROR, "SessionKeepAliveRespMsg send failed: %s", err.Error())
+                }
                 logger.Printf(logger.DBG, ">>> %s", mOut)
 
         case *message.EphemeralKeyMsg:
@@ -171,9 +181,13 @@ func process(ctx context.Context, ev *core.Event) {
                 }
                 remote.SetEphKeyMsg(msg)
                 mOut := local.EphKeyMsg()
-                c.Send(ctx, ev.Peer, mOut)
+                if err := c.Send(ctx, ev.Peer, mOut); err != nil {
+                        logger.Printf(logger.ERROR, "EphKeyMsg send failed: %s", err.Error())
+                }
                 logger.Printf(logger.DBG, ">>> %s", mOut)
-                secret = crypto.SharedSecret(local.EphPrvKey(), remote.EphKeyMsg().Public())
+                pk := ed25519.NewPublicKeyFromBytes(remote.EphKeyMsg().Public().Data)
+                secret = crypto.SharedSecret(local.EphPrvKey(), pk)
+                fmt.Printf("Shared secret: %s\n", secret.String())
 
         default:
                 fmt.Printf("!!! %v\n", msg)