github.com/status-im/status-go@v1.1.0/protocol/encryption/protocol_test.go (about)

     1  package encryption
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/status-im/status-go/appdatabase"
     7  	"github.com/status-im/status-go/protocol/sqlite"
     8  	"github.com/status-im/status-go/protocol/tt"
     9  	"github.com/status-im/status-go/t/helpers"
    10  
    11  	"github.com/stretchr/testify/suite"
    12  	"go.uber.org/zap"
    13  
    14  	"github.com/status-im/status-go/eth-node/crypto"
    15  )
    16  
    17  func TestProtocolServiceTestSuite(t *testing.T) {
    18  	suite.Run(t, new(ProtocolServiceTestSuite))
    19  }
    20  
    21  type ProtocolServiceTestSuite struct {
    22  	suite.Suite
    23  	alice  *Protocol
    24  	bob    *Protocol
    25  	logger *zap.Logger
    26  }
    27  
    28  func (s *ProtocolServiceTestSuite) SetupTest() {
    29  	var err error
    30  
    31  	s.logger = tt.MustCreateTestLogger()
    32  
    33  	db, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{})
    34  	s.Require().NoError(err)
    35  	err = sqlite.Migrate(db)
    36  	s.Require().NoError(err)
    37  	s.alice = New(
    38  		db,
    39  		"1",
    40  		s.logger.With(zap.String("user", "alice")),
    41  	)
    42  
    43  	db, err = helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{})
    44  	s.Require().NoError(err)
    45  	err = sqlite.Migrate(db)
    46  	s.Require().NoError(err)
    47  	s.bob = New(
    48  		db,
    49  		"2",
    50  		s.logger.With(zap.String("user", "bob")),
    51  	)
    52  }
    53  
    54  func (s *ProtocolServiceTestSuite) TearDownTest() {
    55  	_ = s.logger.Sync()
    56  }
    57  
    58  func (s *ProtocolServiceTestSuite) TestBuildPublicMessage() {
    59  	aliceKey, err := crypto.GenerateKey()
    60  	s.NoError(err)
    61  
    62  	payload := []byte("test")
    63  	s.NoError(err)
    64  
    65  	msg, err := s.alice.BuildPublicMessage(aliceKey, payload)
    66  	s.NoError(err)
    67  	s.NotNil(msg, "It creates a message")
    68  
    69  	s.NotNilf(msg.Message.GetBundles(), "It adds a bundle to the message")
    70  }
    71  
    72  func (s *ProtocolServiceTestSuite) TestBuildEncryptedMessage() {
    73  	bobKey, err := crypto.GenerateKey()
    74  	s.NoError(err)
    75  	aliceKey, err := crypto.GenerateKey()
    76  	s.NoError(err)
    77  
    78  	payload := []byte("test")
    79  
    80  	msgSpec, err := s.alice.BuildEncryptedMessage(aliceKey, &bobKey.PublicKey, payload)
    81  	s.NoError(err)
    82  	s.NotNil(msgSpec, "It creates a message spec")
    83  
    84  	msg := msgSpec.Message
    85  	s.NotNil(msg, "It creates a messages")
    86  
    87  	s.NotNilf(msg.GetBundles(), "It adds a bundle to the message")
    88  
    89  	directMessage := msg.GetEncryptedMessage()
    90  	s.NotNilf(directMessage, "It sets the direct message")
    91  
    92  	encryptedPayload := directMessage["none"].GetPayload()
    93  	s.NotNilf(encryptedPayload, "It sets the payload of the message")
    94  
    95  	s.NotEqualf(payload, encryptedPayload, "It encrypts the payload")
    96  }
    97  
    98  func (s *ProtocolServiceTestSuite) TestBuildAndReadEncryptedMessage() {
    99  	bobKey, err := crypto.GenerateKey()
   100  	s.Require().NoError(err)
   101  	aliceKey, err := crypto.GenerateKey()
   102  	s.Require().NoError(err)
   103  
   104  	payload := []byte("test")
   105  
   106  	// Message is sent with DH
   107  	msgSpec, err := s.alice.BuildEncryptedMessage(aliceKey, &bobKey.PublicKey, payload)
   108  	s.Require().NoError(err)
   109  	s.Require().NotNil(msgSpec)
   110  
   111  	msg := msgSpec.Message
   112  	s.Require().NotNil(msg)
   113  
   114  	// Bob is able to decrypt the message
   115  	unmarshaledMsg, err := s.bob.HandleMessage(bobKey, &aliceKey.PublicKey, msg, []byte("message-id"))
   116  	s.NoError(err)
   117  	s.NotNil(unmarshaledMsg)
   118  
   119  	recoveredPayload := []byte("test")
   120  	s.Equalf(payload, recoveredPayload, "It successfully unmarshal the decrypted message")
   121  }
   122  
   123  func (s *ProtocolServiceTestSuite) TestSecretNegotiation() {
   124  	bobKey, err := crypto.GenerateKey()
   125  	s.NoError(err)
   126  	aliceKey, err := crypto.GenerateKey()
   127  	s.NoError(err)
   128  
   129  	payload := []byte("test")
   130  
   131  	_, err = s.bob.Start(bobKey)
   132  	s.Require().NoError(err)
   133  
   134  	msgSpec, err := s.alice.BuildEncryptedMessage(aliceKey, &bobKey.PublicKey, payload)
   135  	s.NoError(err)
   136  	s.NotNil(msgSpec, "It creates a message spec")
   137  	s.Require().NotNil(msgSpec.SharedSecret)
   138  
   139  	bundle := msgSpec.Message.GetBundles()[0]
   140  	s.Require().NotNil(bundle)
   141  
   142  	signedPreKeys := bundle.GetSignedPreKeys()
   143  	s.Require().NotNil(signedPreKeys)
   144  
   145  	signedPreKey := signedPreKeys["1"]
   146  	s.Require().NotNil(signedPreKey)
   147  
   148  	s.Require().Equal(uint32(1), signedPreKey.GetProtocolVersion())
   149  
   150  	_, err = s.bob.HandleMessage(bobKey, &aliceKey.PublicKey, msgSpec.Message, []byte("message-id"))
   151  	s.NoError(err)
   152  
   153  	s.Require().NoError(s.bob.Stop())
   154  }
   155  
   156  func (s *ProtocolServiceTestSuite) TestPropagatingSavedSharedSecretsOnStart() {
   157  	aliceKey, err := crypto.GenerateKey()
   158  	s.NoError(err)
   159  	bobKey, err := crypto.GenerateKey()
   160  	s.NoError(err)
   161  
   162  	// Generate and save a shared secret.
   163  	generatedSecret, err := s.alice.secret.Generate(aliceKey, &bobKey.PublicKey, "installation-1")
   164  	s.NoError(err)
   165  
   166  	subscriptions, err := s.alice.Start(aliceKey)
   167  	s.Require().NoError(err)
   168  
   169  	secretResponse := subscriptions.SharedSecrets
   170  
   171  	s.Require().NotNil(secretResponse)
   172  	s.Require().Len(secretResponse, 1)
   173  	s.Equal(crypto.FromECDSAPub(generatedSecret.Identity), crypto.FromECDSAPub(secretResponse[0].Identity))
   174  	s.Equal(generatedSecret.Key, secretResponse[0].Key)
   175  	s.Require().NoError(s.alice.Stop())
   176  }