Add support for encrypted messages

Author: AchoArnold

cipher_service.go

@@ -0,0 +1,66 @@
+package httpsms
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+)
+
+// CipherService is used to encrypt and decrypt SMS messages using the AES-256 algorithm
+type CipherService service
+
+// Encrypt the message content using the encryption key
+func (service *CipherService) Encrypt(encryptionKey string, content string) (string, error) {
+	block, err := aes.NewCipher(service.hash(encryptionKey))
+	if err != nil {
+		return "", errors.Join(err, errors.New("failed to create new cipher"))
+	}
+
+	text := []byte(content)
+
+	iv, err := service.initializationVector()
+	if err != nil {
+		return "", errors.Join(err, errors.New("failed to create initialization vector"))
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	cipherText := make([]byte, len(text))
+	stream.XORKeyStream(cipherText, text)
+
+	return base64.StdEncoding.EncodeToString(append(iv, cipherText...)), nil
+}
+
+// Decrypt the message content using the encryption key
+func (service *CipherService) Decrypt(encryptionKey string, cipherText string) (string, error) {
+	content, err := base64.StdEncoding.DecodeString(cipherText)
+	if err != nil {
+		return "", errors.Join(err, errors.New("failed to decode cipher in base64"))
+	}
+
+	block, err := aes.NewCipher(service.hash(encryptionKey))
+	if err != nil {
+		return "", errors.Join(err, errors.New("failed to create new cipher"))
+	}
+
+	// Decrypt the message
+	cipherTextBytes := content[16:]
+	stream := cipher.NewCFBDecrypter(block, content[:16])
+	stream.XORKeyStream(cipherTextBytes, cipherTextBytes)
+
+	return string(cipherTextBytes), nil
+}
+
+// hash a key using the SHA-256 algorithm
+func (service *CipherService) hash(key string) []byte {
+	sha := sha256.Sum256([]byte(key))
+	return sha[:]
+}
+
+func (service *CipherService) initializationVector() ([]byte, error) {
+	iv := make([]byte, 16)
+	_, err := rand.Read(iv)
+	return iv, err
+}

cipher_service_test.go

@@ -0,0 +1,22 @@
+package httpsms
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestCipherService(t *testing.T) {
+	// Arrange
+	key := "Password123"
+	message := "This is a test text message"
+	client := New()
+
+	// Act
+	encryptedMessage, encryptErr := client.Cipher.Encrypt(key, message)
+	decryptedMessage, decryptErr := client.Cipher.Decrypt(key, encryptedMessage)
+
+	// Assert
+	assert.Nil(t, encryptErr)
+	assert.Nil(t, decryptErr)
+	assert.Equal(t, message, decryptedMessage)
+}

client.go

@@ -24,6 +24,7 @@ type Client struct {
 	MessageThreads *MessageThreadService
 	Heartbeats     *HeartbeatService
 	Messages       *MessageService
+	Cipher         *CipherService
 }
 
 // New creates and returns a new campay.Client from a slice of campay.ClientOption.
@@ -44,6 +45,8 @@ func New(options ...Option) *Client {
 	client.Messages = (*MessageService)(&client.common)
 	client.Heartbeats = (*HeartbeatService)(&client.common)
 	client.MessageThreads = (*MessageThreadService)(&client.common)
+	client.Cipher = (*CipherService)(&client.common)
+
 	return client
 }
 

heartbeat_service_test.go

@@ -0,0 +1,66 @@
+package httpsms
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/NdoleStudio/httpsms-go/internal/helpers"
+	"github.com/NdoleStudio/httpsms-go/internal/stubs"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"testing"
+)
+
+func TestHeartbeatService_Index(t *testing.T) {
+	// Setup
+	t.Parallel()
+
+	// Arrange
+	apiKey := "test-api-key"
+	server := helpers.MakeTestServer(http.StatusOK, stubs.HeartbeatIndexResponse())
+	client := New(WithBaseURL(server.URL), WithAPIKey(apiKey))
+
+	// Act
+	heartbeats, response, err := client.Heartbeats.Index(context.Background(), &HeartbeatIndexParams{
+		Skip:  0,
+		Owner: "+18005550199",
+		Query: nil,
+		Limit: 100,
+	})
+
+	// Assert
+	assert.Nil(t, err)
+
+	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
+
+	jsonContent, _ := json.Marshal(heartbeats)
+	assert.JSONEq(t, string(stubs.HeartbeatIndexResponse()), string(jsonContent))
+
+	// Teardown
+	server.Close()
+}
+
+func TestHeartbeatService_IndexWithError(t *testing.T) {
+	// Setup
+	t.Parallel()
+
+	// Arrange
+	apiKey := "test-api-key"
+	server := helpers.MakeTestServer(http.StatusInternalServerError, stubs.MessagesSendErrorResponse())
+	client := New(WithBaseURL(server.URL), WithAPIKey(apiKey))
+
+	// Act
+	_, response, err := client.Heartbeats.Index(context.Background(), &HeartbeatIndexParams{
+		Skip:  0,
+		Owner: "+18005550199",
+		Query: nil,
+		Limit: 100,
+	})
+
+	// Assert
+	assert.NotNil(t, err)
+	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
+	assert.Equal(t, string(stubs.MessagesSendErrorResponse()), string(*response.Body))
+
+	// Teardown
+	server.Close()
+}

internal/stubs/heartbeat.go

@@ -0,0 +1,20 @@
+package stubs
+
+// HeartbeatIndexResponse response from the /v1/heartbeats endpoint
+func HeartbeatIndexResponse() []byte {
+	return []byte(`
+{
+    "data": [
+        {
+            "id": "9d484671-cac2-41de-9171-d9d2c1835d7b",
+            "owner": "+18005550199",
+            "user_id": "hT5V2CmN5bbG81glMLmosxPV9Np2",
+            "charging": true,
+            "timestamp": "2024-01-21T13:07:56.203538Z"
+        }
+    ],
+    "message": "fetched 1 heartbeat",
+    "status": "success"
+}
+`)
+}

internal/stubs/message.go

@@ -27,6 +27,7 @@ func MessagesSendResponse() []byte {
 				"sent_at": "2022-06-05T14:26:09.527976+03:00",
 				"sim": "SIM1",
 				"status": "pending",
+				"encrypted": false,	
 				"type": "mobile-terminated",
 				"updated_at": "2022-06-05T14:26:10.303278+03:00",
 				"user_id": "WB7DRDWrJZRGbYrv2CKGkqbzvqdC"

message.go

@@ -10,6 +10,7 @@ import (
 type MessageSendParams struct {
 	Content   string `json:"content"`
 	From      string `json:"from"`
+	Encrypted bool   `json:"encrypted"`
 	RequestID string `json:"request_id,omitempty"`
 	To        string `json:"to"`
 }
@@ -39,6 +40,8 @@ type Message struct {
 	Content   string    `json:"content" example:"This is a sample text message"`
 	Type      string    `json:"type" example:"mobile-terminated"`
 	Status    string    `json:"status" example:"pending"`
+	Encrypted bool      `json:"encrypted" example:"false"`
+
 	// SIM is the SIM card to use to send the message
 	// * SMS1: use the SIM card in slot 1
 	// * SMS2: use the SIM card in slot 2