package rpc import ( "crypto/ecdsa" "crypto/rand" "fmt" "net/http" "strings" "sync" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" "github.com/status-im/go-waku/waku/v2/node" "github.com/status-im/go-waku/waku/v2/protocol" "github.com/status-im/go-waku/waku/v2/protocol/pb" "github.com/status-im/go-waku/waku/v2/protocol/relay" "github.com/status-im/go-waku/waku/v2/utils" "go.uber.org/zap" ) type PrivateService struct { node *node.WakuNode log *zap.Logger messages map[string][]*pb.WakuMessage cacheCapacity int messagesMutex sync.RWMutex runner *runnerService } type SymmetricKeyReply string type KeyPairReply struct { PrivateKey string `json:"privateKey"` PublicKey string `json:"publicKey"` } type SymmetricMessageArgs struct { Topic string `json:"topic"` Message RPCWakuMessage `json:"message"` SymKey string `json:"symkey"` } type AsymmetricMessageArgs struct { Topic string `json:"topic"` Message RPCWakuMessage `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, cacheCapacity int, log *zap.Logger) *PrivateService { p := &PrivateService{ node: node, cacheCapacity: cacheCapacity, messages: make(map[string][]*pb.WakuMessage), log: log.Named("private"), } p.runner = newRunnerService(node.Broadcaster(), p.addEnvelope) return p } func (p *PrivateService) addEnvelope(envelope *protocol.Envelope) { p.messagesMutex.Lock() defer p.messagesMutex.Unlock() if _, ok := p.messages[envelope.PubsubTopic()]; !ok { p.messages[envelope.PubsubTopic()] = make([]*pb.WakuMessage, 0) } // Keep a specific max number of messages per topic if len(p.messages[envelope.PubsubTopic()]) >= p.cacheCapacity { p.messages[envelope.PubsubTopic()] = p.messages[envelope.PubsubTopic()][1:] } p.messages[envelope.PubsubTopic()] = append(p.messages[envelope.PubsubTopic()], envelope.Message()) } func (p *PrivateService) GetV1SymmetricKey(req *http.Request, args *Empty, reply *SymmetricKeyReply) error { key := [32]byte{} _, err := rand.Read(key[:]) if err != nil { return err } *reply = SymmetricKeyReply(hexutil.Encode(key[:])) return nil } func (p *PrivateService) GetV1AsymmetricKeypair(req *http.Request, args *Empty, reply *KeyPairReply) error { privateKey, err := crypto.GenerateKey() if err != nil { return err } privateKeyBytes := crypto.FromECDSA(privateKey) publicKey := privateKey.Public() publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey) if !ok { return fmt.Errorf("cannot assert type: publicKey is not of type *ecdsa.PublicKey") } publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA) reply.PrivateKey = hexutil.Encode(privateKeyBytes[:]) reply.PublicKey = hexutil.Encode(publicKeyBytes[:]) return nil } func (p *PrivateService) PostV1SymmetricMessage(req *http.Request, args *SymmetricMessageArgs, reply *SuccessReply) error { symKeyBytes, err := utils.DecodeHexString(args.SymKey) if err != nil { return fmt.Errorf("invalid symmetric key: %w", err) } keyInfo := new(node.KeyInfo) keyInfo.Kind = node.Symmetric keyInfo.SymKey = symKeyBytes msg := args.Message.toProto() msg.Version = 1 err = node.EncodeWakuMessage(msg, keyInfo) if err != nil { return err } topic := args.Topic if topic == "" { topic = relay.DefaultWakuTopic } _, err = p.node.Relay().PublishToTopic(req.Context(), msg, topic) if err != nil { return err } *reply = true return nil } func (p *PrivateService) PostV1AsymmetricMessage(req *http.Request, args *AsymmetricMessageArgs, reply *bool) error { keyInfo := new(node.KeyInfo) keyInfo.Kind = node.Asymmetric pubKeyBytes, err := utils.DecodeHexString(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 msg := args.Message.toProto() msg.Version = 1 err = node.EncodeWakuMessage(msg, keyInfo) if err != nil { return err } topic := args.Topic if topic == "" { topic = relay.DefaultWakuTopic } _, err = p.node.Relay().PublishToTopic(req.Context(), msg, topic) if err != nil { return err } *reply = true return nil } func (p *PrivateService) GetV1SymmetricMessages(req *http.Request, args *SymmetricMessagesArgs, reply *MessagesReply) error { p.messagesMutex.Lock() defer p.messagesMutex.Unlock() if _, ok := p.messages[args.Topic]; !ok { p.messages[args.Topic] = make([]*pb.WakuMessage, 0) } symKeyBytes, err := utils.DecodeHexString(args.SymKey) if err != nil { return fmt.Errorf("invalid symmetric key: %w", err) } messages := make([]*pb.WakuMessage, len(p.messages[args.Topic])) copy(messages, p.messages[args.Topic]) p.messages[args.Topic] = make([]*pb.WakuMessage, 0) var decodedMessages []*pb.WakuMessage for _, msg := range messages { err := node.DecodeWakuMessage(msg, &node.KeyInfo{ Kind: node.Symmetric, SymKey: symKeyBytes, }) if err != nil { continue } decodedMessages = append(decodedMessages, msg) } for i := range decodedMessages { *reply = append(*reply, ProtoWakuMessageToRPCWakuMessage(decodedMessages[i])) } return nil } func (p *PrivateService) GetV1AsymmetricMessages(req *http.Request, args *AsymmetricMessagesArgs, reply *MessagesReply) error { p.messagesMutex.Lock() defer p.messagesMutex.Unlock() if _, ok := p.messages[args.Topic]; !ok { p.messages[args.Topic] = make([]*pb.WakuMessage, 0) } messages := make([]*pb.WakuMessage, len(p.messages[args.Topic])) copy(messages, p.messages[args.Topic]) p.messages[args.Topic] = make([]*pb.WakuMessage, 0) privKey, err := crypto.HexToECDSA(strings.TrimPrefix(args.PrivateKey, "0x")) if err != nil { return fmt.Errorf("invalid asymmetric key: %w", err) } var decodedMessages []*pb.WakuMessage for _, msg := range messages { err := node.DecodeWakuMessage(msg, &node.KeyInfo{ Kind: node.Asymmetric, PrivKey: privKey, }) if err != nil { continue } decodedMessages = append(decodedMessages, msg) } for i := range decodedMessages { *reply = append(*reply, ProtoWakuMessageToRPCWakuMessage(decodedMessages[i])) } return nil } func (p *PrivateService) Start() { p.runner.Start() } func (p *PrivateService) Stop() { p.runner.Stop() }