Fix cycle import and added private key to Client

protocol/common/message.go

@@ -19,7 +19,6 @@ import (
 	"github.com/status-im/status-go/eth-node/crypto"
 	"github.com/status-im/status-go/images"
 	"github.com/status-im/status-go/protocol/protobuf"
-	"github.com/status-im/status-go/server"
 )
 
 // QuotedMessage contains the original text of the message replied to
@@ -174,23 +173,6 @@ type Message struct {
 	ContactRequestState ContactRequestState `json:"contactRequestState,omitempty"`
 }
 
-func (m *Message) PrepareServerURLs(s *server.MediaServer) {
-	m.Identicon = s.MakeIdenticonURL(m.From)
-
-	if m.QuotedMessage != nil && m.QuotedMessage.ContentType == int64(protobuf.ChatMessage_IMAGE) {
-		m.QuotedMessage.ImageLocalURL = s.MakeImageURL(m.QuotedMessage.ID)
-	}
-	if m.ContentType == protobuf.ChatMessage_IMAGE {
-		m.ImageLocalURL = s.MakeImageURL(m.ID)
-	}
-	if m.ContentType == protobuf.ChatMessage_AUDIO {
-		m.AudioLocalURL = s.MakeAudioURL(m.ID)
-	}
-	if m.ContentType == protobuf.ChatMessage_STICKER {
-		m.StickerLocalURL = s.MakeStickerURL(m.GetSticker().Hash)
-	}
-}
-
 func (m *Message) MarshalJSON() ([]byte, error) {
 	type StickerAlias struct {
 		Hash string `json:"hash"`

protocol/messenger.go

@@ -4252,7 +4252,7 @@ func (m *Messenger) MessageByChatID(chatID, cursor string, limit int) ([]*common
 	}
 	if m.httpServer != nil {
 		for idx := range msgs {
-			msgs[idx].PrepareServerURLs(m.httpServer)
+			m.prepareMessage(msgs[idx], m.httpServer)
 		}
 	}
 
@@ -4262,11 +4262,28 @@ func (m *Messenger) MessageByChatID(chatID, cursor string, limit int) ([]*common
 func (m *Messenger) prepareMessages(messages map[string]*common.Message) {
 	if m.httpServer != nil {
 		for idx := range messages {
-			messages[idx].PrepareServerURLs(m.httpServer)
+			m.prepareMessage(messages[idx], m.httpServer)
 		}
 	}
 }
 
+func (m *Messenger) prepareMessage(msg *common.Message, s *server.MediaServer) {
+	msg.Identicon = s.MakeIdenticonURL(msg.From)
+
+	if msg.QuotedMessage != nil && msg.QuotedMessage.ContentType == int64(protobuf.ChatMessage_IMAGE) {
+		msg.QuotedMessage.ImageLocalURL = s.MakeImageURL(msg.QuotedMessage.ID)
+	}
+	if msg.ContentType == protobuf.ChatMessage_IMAGE {
+		msg.ImageLocalURL = s.MakeImageURL(msg.ID)
+	}
+	if msg.ContentType == protobuf.ChatMessage_AUDIO {
+		msg.AudioLocalURL = s.MakeAudioURL(msg.ID)
+	}
+	if msg.ContentType == protobuf.ChatMessage_STICKER {
+		msg.StickerLocalURL = s.MakeStickerURL(msg.GetSticker().Hash)
+	}
+}
+
 func (m *Messenger) AllMessageByChatIDWhichMatchTerm(chatID string, searchTerm string, caseSensitive bool) ([]*common.Message, error) {
 	_, err := m.persistence.Chat(chatID)
 	if err != nil {

server/certs_test.go

@@ -1,11 +1,14 @@
 package server
 
 import (
+	"crypto/rand"
 	"testing"
 	"time"
 
 	"github.com/btcsuite/btcutil/base58"
 	"github.com/stretchr/testify/suite"
+
+	"github.com/status-im/status-go/protocol/common"
 )
 
 func TestCerts(t *testing.T) {
@@ -53,3 +56,15 @@ func (s *CertsSuite) TestGenerateX509Cert() {
 	s.Require().Equal(defaultIP.String(), c2.IPAddresses[0].String())
 	s.Require().Nil(c2.DNSNames)
 }
+
+func (s *CertsSuite) Test() {
+	text := []byte("I am a test")
+
+	cypher, err := common.Encrypt(text, s.PK.D.Bytes(), rand.Reader)
+	s.Require().NoError(err)
+	s.Require().NotEqual(text, cypher)
+
+	out, err := common.Decrypt(cypher, s.PK.D.Bytes())
+	s.Require().NoError(err)
+	s.Require().Equal(text, out)
+}

server/client.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"crypto/ecdsa"
 	"crypto/tls"
 	"crypto/x509"
 	"fmt"
@@ -12,7 +13,8 @@ type Client struct {
 	*http.Client
 
 	baseAddress *url.URL
-	certPEM []byte
+	certPEM     []byte
+	privateKey  *ecdsa.PrivateKey
 }
 
 func NewClient(c *ConnectionParams) (*Client, error) {
@@ -42,5 +44,6 @@ func NewClient(c *ConnectionParams) (*Client, error) {
 		Client:      &http.Client{Transport: tr},
 		baseAddress: u,
 		certPEM:     certPem,
+		privateKey:  c.privateKey,
 	}, nil
 }

vendor/github.com/marten-seemann/qtls-go1-18/generate_cert.go

@@ -1,172 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build ignore
-
-// Generate a self-signed X.509 certificate for a TLS server. Outputs to
-// 'cert.pem' and 'key.pem' and will overwrite existing files.
-
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"flag"
-	"log"
-	"math/big"
-	"net"
-	"os"
-	"strings"
-	"time"
-)
-
-var (
-	host       = flag.String("host", "", "Comma-separated hostnames and IPs to generate a certificate for")
-	validFrom  = flag.String("start-date", "", "Creation date formatted as Jan 1 15:04:05 2011")
-	validFor   = flag.Duration("duration", 365*24*time.Hour, "Duration that certificate is valid for")
-	isCA       = flag.Bool("ca", false, "whether this cert should be its own Certificate Authority")
-	rsaBits    = flag.Int("rsa-bits", 2048, "Size of RSA key to generate. Ignored if --ecdsa-curve is set")
-	ecdsaCurve = flag.String("ecdsa-curve", "", "ECDSA curve to use to generate a key. Valid values are P224, P256 (recommended), P384, P521")
-	ed25519Key = flag.Bool("ed25519", false, "Generate an Ed25519 key")
-)
-
-func publicKey(priv any) any {
-	switch k := priv.(type) {
-	case *rsa.PrivateKey:
-		return &k.PublicKey
-	case *ecdsa.PrivateKey:
-		return &k.PublicKey
-	case ed25519.PrivateKey:
-		return k.Public().(ed25519.PublicKey)
-	default:
-		return nil
-	}
-}
-
-func main() {
-	flag.Parse()
-
-	if len(*host) == 0 {
-		log.Fatalf("Missing required --host parameter")
-	}
-
-	var priv any
-	var err error
-	switch *ecdsaCurve {
-	case "":
-		if *ed25519Key {
-			_, priv, err = ed25519.GenerateKey(rand.Reader)
-		} else {
-			priv, err = rsa.GenerateKey(rand.Reader, *rsaBits)
-		}
-	case "P224":
-		priv, err = ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
-	case "P256":
-		priv, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	case "P384":
-		priv, err = ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
-	case "P521":
-		priv, err = ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
-	default:
-		log.Fatalf("Unrecognized elliptic curve: %q", *ecdsaCurve)
-	}
-	if err != nil {
-		log.Fatalf("Failed to generate private key: %v", err)
-	}
-
-	// ECDSA, ED25519 and RSA subject keys should have the DigitalSignature
-	// KeyUsage bits set in the x509.Certificate template
-	keyUsage := x509.KeyUsageDigitalSignature
-	// Only RSA subject keys should have the KeyEncipherment KeyUsage bits set. In
-	// the context of TLS this KeyUsage is particular to RSA key exchange and
-	// authentication.
-	if _, isRSA := priv.(*rsa.PrivateKey); isRSA {
-		keyUsage |= x509.KeyUsageKeyEncipherment
-	}
-
-	var notBefore time.Time
-	if len(*validFrom) == 0 {
-		notBefore = time.Now()
-	} else {
-		notBefore, err = time.Parse("Jan 2 15:04:05 2006", *validFrom)
-		if err != nil {
-			log.Fatalf("Failed to parse creation date: %v", err)
-		}
-	}
-
-	notAfter := notBefore.Add(*validFor)
-
-	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
-	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
-	if err != nil {
-		log.Fatalf("Failed to generate serial number: %v", err)
-	}
-
-	template := x509.Certificate{
-		SerialNumber: serialNumber,
-		Subject: pkix.Name{
-			Organization: []string{"Acme Co"},
-		},
-		NotBefore: notBefore,
-		NotAfter:  notAfter,
-
-		KeyUsage:              keyUsage,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-	}
-
-	hosts := strings.Split(*host, ",")
-	for _, h := range hosts {
-		if ip := net.ParseIP(h); ip != nil {
-			template.IPAddresses = append(template.IPAddresses, ip)
-		} else {
-			template.DNSNames = append(template.DNSNames, h)
-		}
-	}
-
-	if *isCA {
-		template.IsCA = true
-		template.KeyUsage |= x509.KeyUsageCertSign
-	}
-
-	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv)
-	if err != nil {
-		log.Fatalf("Failed to create certificate: %v", err)
-	}
-
-	certOut, err := os.Create("cert.pem")
-	if err != nil {
-		log.Fatalf("Failed to open cert.pem for writing: %v", err)
-	}
-	if err := pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
-		log.Fatalf("Failed to write data to cert.pem: %v", err)
-	}
-	if err := certOut.Close(); err != nil {
-		log.Fatalf("Error closing cert.pem: %v", err)
-	}
-	log.Print("wrote cert.pem\n")
-
-	keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		log.Fatalf("Failed to open key.pem for writing: %v", err)
-		return
-	}
-	privBytes, err := x509.MarshalPKCS8PrivateKey(priv)
-	if err != nil {
-		log.Fatalf("Unable to marshal private key: %v", err)
-	}
-	if err := pem.Encode(keyOut, &pem.Block{Type: "PRIVATE KEY", Bytes: privBytes}); err != nil {
-		log.Fatalf("Failed to write data to key.pem: %v", err)
-	}
-	if err := keyOut.Close(); err != nil {
-		log.Fatalf("Error closing key.pem: %v", err)
-	}
-	log.Print("wrote key.pem\n")
-}