feat: private rpc encrypt message

waku/v2/rpc/private.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/status-im/go-waku/waku/v2/node"
+	"github.com/status-im/go-waku/waku/v2/protocol/pb"
 )
 
 type PrivateService struct {
@@ -24,6 +25,34 @@ type KeyPairReply struct {
 	PulicKey   string `json:"publicKey"`
 }
 
+type SymmetricMessageArgs struct {
+	Topic   string         `json:"topic"`
+	Message pb.WakuMessage `json:"message"`
+	SymKey  string         `json:"symkey"`
+}
+
+type AsymmetricMessageArgs struct {
+	Topic     string         `json:"topic"`
+	Message   pb.WakuMessage `json:"message"`
+	PublicKey string         `json:"publicKey"`
+}
+
+type SymmetricMessagesArgs struct {
+	Topic  string `json:"topic"`
+	SymKey string `json:"symkey"`
+}
+
+type AsymmetricMessagesArgs struct {
+	Topic      string `json:"topic"`
+	PrivateKey string `json:"privateKey"`
+}
+
+func NewPrivateService(node *node.WakuNode) *PrivateService {
+	return &PrivateService{
+		node: node,
+	}
+}
+
 func (p *PrivateService) GetV1SymmetricKey(req *http.Request, args *Empty, reply *SymmetricKeyReply) error {
 	key := [32]byte{}
 	_, err := rand.Read(key[:])
@@ -53,18 +82,51 @@ func (p *PrivateService) GetV1AsymmetricKeypair(req *http.Request, args *Empty,
 	return nil
 }
 
-func (p *PrivateService) PostV1SymmetricMessage(req *http.Request, args *Empty, reply *SuccessReply) error {
+func (p *PrivateService) PostV1SymmetricMessage(req *http.Request, args *SymmetricMessageArgs, reply *SuccessReply) error {
+	keyInfo := new(node.KeyInfo)
+	keyInfo.Kind = node.Symmetric
+	keyInfo.SymKey = []byte(args.SymKey)
+
+	err := node.EncodeWakuMessage(&args.Message, keyInfo)
+	if err != nil {
+		reply.Error = err.Error()
+		reply.Success = false
+	} else {
+		reply.Success = true
+	}
+
+	return nil
+}
+
+func (p *PrivateService) PostV1AsymmetricMessage(req *http.Request, args *AsymmetricMessageArgs, reply *SuccessReply) error {
+	keyInfo := new(node.KeyInfo)
+	keyInfo.Kind = node.Asymmetric
+	pubKeyBytes, err := hex.DecodeString(args.PublicKey)
+	if err != nil {
+		return fmt.Errorf("public key cannot be decoded: %v", err)
+	}
+
+	pubKey, err := crypto.UnmarshalPubkey(pubKeyBytes)
+	if err != nil {
+		return fmt.Errorf("public key cannot be unmarshalled: %v", err)
+	}
+	keyInfo.PubKey = *pubKey
+
+	err = node.EncodeWakuMessage(&args.Message, keyInfo)
+	if err != nil {
+		reply.Error = err.Error()
+		reply.Success = false
+	} else {
+		reply.Success = true
+	}
+
+	return nil
+}
+
+func (p *PrivateService) GetV1SymmetricMessages(req *http.Request, args *SymmetricMessagesArgs, reply *MessagesReply) error {
 	return fmt.Errorf("not implemented")
 }
 
-func (p *PrivateService) PostV1AsymmetricMessage(req *http.Request, args *Empty, reply *SuccessReply) error {
+func (p *PrivateService) GetV1AsymmetricMessages(req *http.Request, args *AsymmetricMessagesArgs, reply *MessagesReply) error {
-	return fmt.Errorf("not implemented")
-}
-
-func (p *PrivateService) GetV1SymmetricMessages(req *http.Request, args *Empty, reply *SuccessReply) error {
-	return fmt.Errorf("not implemented")
-}
-
-func (p *PrivateService) GetV1AsymmetricMessages(req *http.Request, args *Empty, reply *SuccessReply) error {
 	return fmt.Errorf("not implemented")
 }

waku/v2/rpc/private_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/status-im/go-waku/waku/v2/node"
+	"github.com/status-im/go-waku/waku/v2/protocol/pb"
 	"github.com/stretchr/testify/require"
 )
 
@@ -31,7 +32,7 @@ func TestGetV1SymmetricKey(t *testing.T) {
 	require.NotEmpty(t, reply.Key)
 }
 
-func TestGetV1AsymmetricKeypair(t *testing.T) {
+func TestGetV1AsymmetricKey(t *testing.T) {
 	d := makePrivateService(t)
 	defer d.node.Stop()
 
@@ -42,6 +43,42 @@ func TestGetV1AsymmetricKeypair(t *testing.T) {
 		&reply,
 	)
 	require.NoError(t, err)
-	require.NotEmpty(t, reply.PrivateKey)
 	require.NotEmpty(t, reply.PulicKey)
+	require.NotEmpty(t, reply.PrivateKey)
+}
+
+func TestPostV1SymmetricMessage(t *testing.T) {
+	d := makePrivateService(t)
+	defer d.node.Stop()
+
+	var reply SuccessReply
+	err := d.PostV1SymmetricMessage(
+		makeRequest(t),
+		&SymmetricMessageArgs{
+			Topic:   "test",
+			Message: pb.WakuMessage{Payload: []byte("test")},
+			SymKey:  "abc",
+		},
+		&reply,
+	)
+	require.NoError(t, err)
+	require.True(t, reply.Success)
+}
+
+func TestPostV1AsymmetricMessage(t *testing.T) {
+	d := makePrivateService(t)
+	defer d.node.Stop()
+
+	var reply SuccessReply
+	err := d.PostV1AsymmetricMessage(
+		makeRequest(t),
+		&AsymmetricMessageArgs{
+			Topic:     "test",
+			Message:   pb.WakuMessage{Payload: []byte("test")},
+			PublicKey: "045ded6a56c88173e87a88c55b96956964b1bd3351b5fcb70950a4902fbc1bc0ceabb0ac846c3a4b8f2f6024c0e19f0a7f6a4865035187de5463f34012304fc7c5",
+		},
+		&reply,
+	)
+	require.NoError(t, err)
+	require.True(t, reply.Success)
 }

waku/v2/rpc/waku_rpc.go

@@ -17,8 +17,9 @@ type WakuRpc struct {
 	node   *node.WakuNode
 	server *http.Server
 
-	relayService  *RelayService
+	relayService   *RelayService
-	filterService *FilterService
+	filterService  *FilterService
+	privateService *PrivateService
 }
 
 func NewWakuRpc(node *node.WakuNode, address string, port int) *WakuRpc {
@@ -53,7 +54,8 @@ func NewWakuRpc(node *node.WakuNode, address string, port int) *WakuRpc {
 		log.Error(err)
 	}
 
-	err = s.RegisterService(&PrivateService{node}, "Private")
+	privateService := NewPrivateService(node)
+	err = s.RegisterService(privateService, "Private")
 	if err != nil {
 		log.Error(err)
 	}
@@ -78,10 +80,11 @@ func NewWakuRpc(node *node.WakuNode, address string, port int) *WakuRpc {
 	})
 
 	return &WakuRpc{
-		node:          node,
+		node:           node,
-		server:        server,
+		server:         server,
-		relayService:  relayService,
+		relayService:   relayService,
-		filterService: filterService,
+		filterService:  filterService,
+		privateService: privateService,
 	}
 }