blockydevs · 0xMMBD · Dec 14, 2023 · Dec 14, 2023 · Jan 5, 2024 · jnwng
diff --git a/Makefile b/Makefile
@@ -40,7 +40,7 @@ APP_LOAD_PARAMS += $(COMMON_LOAD_PARAMS)
 APPNAME      = "Solana"
 APPVERSION_M = 1
 APPVERSION_N = 4
-APPVERSION_P = 2
+APPVERSION_P = 3
 APPVERSION   = "$(APPVERSION_M).$(APPVERSION_N).$(APPVERSION_P)"
 
 ifeq ($(TARGET_NAME),TARGET_NANOS)

diff --git a/libsol/Makefile b/libsol/Makefile
@@ -18,7 +18,6 @@ ifeq ($(COVERAGE),1)
 	CFLAGS += --coverage
 endif
 
-debug_CFLAGS = -g -fsanitize=address -fsanitize=undefined
 release_CFLAGS = -O2
 
 libsol_source_files = $(filter-out %_test.c,$(wildcard *.c))

diff --git a/libsol/common_byte_strings.h b/libsol/common_byte_strings.h
@@ -83,8 +83,12 @@
         0x00, 0x00
 
 // Sysvars
-
 #define SYSVAR_RENT /* "SysvarRent111111111111111111111111111111111" */                           \
     0x06, 0xa7, 0xd5, 0x17, 0x19, 0x2c, 0x5c, 0x51, 0x21, 0x8c, 0xc9, 0x4c, 0x3d, 0x4a, 0xf1,     \
         0x7f, 0x58, 0xda, 0xee, 0x08, 0x9b, 0xa1, 0xfd, 0x44, 0xe3, 0xdb, 0xd9, 0x8a, 0x00, 0x00, \
         0x00, 0x00
+
+// Domain specifiers
+#define OFFCHAIN_MESSAGE_SIGNING_DOMAIN /* "\xffsolana offchain" */                               \
+    0xff, 0x73, 0x6f, 0x6c, 0x61, 0x6e, 0x61, 0x20, 0x6f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69,     \
+        0x6e
diff --git a/libsol/include/sol/offchain_message_signing.h b/libsol/include/sol/offchain_message_signing.h
@@ -0,0 +1,20 @@
+#pragma once
+#include <stdint.h>
+
+#define OFFCHAIN_MESSAGE_SIGNING_DOMAIN_LENGTH 16
+
+/**
+* 1. Signing domain (16 bytes)
+* 2. Header version (1 byte)
+* 3. Application domain (32 bytes)
+* 4. Message format (1 byte)
+* 5. Signer count (1 bytes)
+* 6. Signers (signer_count *  32 bytes) - assume that only one signer is present
+* 7. Message length (2 bytes)
+*/
+typedef struct OffchainMessageSigningDomain {
+    uint8_t data[OFFCHAIN_MESSAGE_SIGNING_DOMAIN_LENGTH];
+} OffchainMessageSigningDomain;
+
+extern const OffchainMessageSigningDomain offchain_message_signing_domain;
+
diff --git a/libsol/include/sol/parser.h b/libsol/include/sol/parser.h
@@ -59,16 +59,28 @@ typedef struct MessageHeader {
     size_t instructions_length;
 } MessageHeader;
 
+//@TODO move to offchain message sign .h
+#define OFFCHAIN_MESSAGE_APPLICATION_DOMAIN_LENGTH 32
+typedef struct OffchainMessageApplicationDomain {
+    uint8_t data[OFFCHAIN_MESSAGE_APPLICATION_DOMAIN_LENGTH];
+} OffchainMessageApplicationDomain;
+
 typedef struct OffchainMessageHeader {
     uint8_t version;
+    const OffchainMessageApplicationDomain* application_domain;
     uint8_t format;
+    size_t signers_length;
+    const Pubkey* signers;
     uint16_t length;
 } OffchainMessageHeader;
 
 static inline int parser_is_empty(Parser* parser) {
     return parser->buffer_length == 0;
 }
 
+void advance(Parser* parser, size_t num);
+int check_buffer_length(Parser* parser, size_t num);
+
 int parse_u8(Parser* parser, uint8_t* value);
 
 int parse_u32(Parser* parser, uint32_t* value);
@@ -87,13 +99,18 @@ int parse_pubkey(Parser* parser, const Pubkey** pubkey);
 
 int parse_pubkeys_header(Parser* parser, PubkeysHeader* header);
 
-int parse_pubkeys(Parser* parser, PubkeysHeader* header, const Pubkey** pubkeys);
+int parse_pubkeys(Parser* parser, size_t num_pubkeys, const Pubkey** pubkeys);
 
 int parse_blockhash(Parser* parser, const Hash** hash);
 #define parse_blockhash parse_hash
 
 int parse_message_header(Parser* parser, MessageHeader* header);
 
+int parse_offchain_message_application_domain(
+    Parser* parser,
+    const OffchainMessageApplicationDomain** app_domain
+);
+
 int parse_offchain_message_header(Parser* parser, OffchainMessageHeader* header);
 
 int parse_instruction(Parser* parser, Instruction* instruction);

diff --git a/libsol/include/sol/string_utils.h b/libsol/include/sol/string_utils.h
@@ -0,0 +1,7 @@
+#pragma once
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+
+bool is_data_utf8(const uint8_t *data, size_t length);
+bool is_data_ascii(const uint8_t *data, size_t length);
diff --git a/libsol/include/sol/transaction_summary.h b/libsol/include/sol/transaction_summary.h
@@ -2,6 +2,7 @@
 
 #include "sol/parser.h"
 #include "sol/printer.h"
+#include "offchain_message_signing.h"
 
 // TransactionSummary management
 //
@@ -46,16 +47,24 @@ enum SummaryItemKind {
     SummaryItemSizedString,
     SummaryItemString,
     SummaryItemTimestamp,
+    SummaryItemOffchainMessageApplicationDomain,
+    SummaryItemExtendedString,
 };
 
 typedef enum SummaryItemKind SummaryItemKind_t;
 
 typedef struct SummaryItem SummaryItem;
 
 extern char G_transaction_summary_title[TITLE_SIZE];
+
+// Text buffer needs to be large enough to hold the longest possible message text to sign
+//#define TEXT_BUFFER_LENGTH (OFFCHAIN_MESSAGE_MAXIMUM_MESSAGE_LENGTH - OFFCHAIN_MESSAGE_MINIMAL_HEADER_SIZE)
 #define TEXT_BUFFER_LENGTH BASE58_PUBKEY_LENGTH
+
 extern char G_transaction_summary_text[TEXT_BUFFER_LENGTH];
 
+extern char* G_transaction_summary_extended_text;
+
 void transaction_summary_reset();
 enum DisplayFlags {
     DisplayFlagNone = 0,
@@ -71,6 +80,12 @@ SummaryItem* transaction_summary_fee_payer_item();
 SummaryItem* transaction_summary_nonce_account_item();
 SummaryItem* transaction_summary_nonce_authority_item();
 SummaryItem* transaction_summary_general_item();
+uint8_t transaction_summary_general_item_count();
+uint64_t calculate_additional_transaction_fees();
+
+
+
+
 
 
 
@@ -90,4 +105,12 @@ void summary_item_set_pubkey(SummaryItem* item, const char* title, const Pubkey*
 void summary_item_set_hash(SummaryItem* item, const char* title, const Hash* value);
 void summary_item_set_sized_string(SummaryItem* item, const char* title, const SizedString* value);
 void summary_item_set_string(SummaryItem* item, const char* title, const char* value);
+void summary_item_safe_set_string(SummaryItem* item, const char* title, const char* value);
 void summary_item_set_timestamp(SummaryItem* item, const char* title, int64_t value);
+void summary_item_set_offchain_message_application_domain(
+    SummaryItem* item,
+    const char* title,
+    const OffchainMessageApplicationDomain* value
+);
+void summary_item_set_extended_string(SummaryItem* item, const char* title, const char* value);
+void summary_item_safe_set_extended_string(SummaryItem* item, const char* title, const char* value);
diff --git a/libsol/offchain_message_signing.c b/libsol/offchain_message_signing.c
@@ -0,0 +1,5 @@
+#include "sol/offchain_message_signing.h"
+#include "common_byte_strings.h"
+
+const OffchainMessageSigningDomain offchain_message_signing_domain =
+    {{OFFCHAIN_MESSAGE_SIGNING_DOMAIN}};
diff --git a/libsol/parser.c b/libsol/parser.c
@@ -1,15 +1,12 @@
 #include "sol/parser.h"
+#include "sol/offchain_message_signing.h"
 #include "util.h"
 
-#define OFFCHAIN_MESSAGE_SIGNING_DOMAIN \
-    "\xff"                              \
-    "solana offchain"
-
-static int check_buffer_length(Parser* parser, size_t num) {
+int check_buffer_length(Parser* parser, size_t num) {
     return parser->buffer_length < num ? 1 : 0;
 }
 
-static void advance(Parser* parser, size_t num) {
+void advance(Parser* parser, size_t num) {
     parser->buffer += num;
     parser->buffer_length -= num;
 }
@@ -106,9 +103,8 @@ int parse_pubkeys_header(Parser* parser, PubkeysHeader* header) {
     return 0;
 }
 
-int parse_pubkeys(Parser* parser, PubkeysHeader* header, const Pubkey** pubkeys) {
-    BAIL_IF(parse_pubkeys_header(parser, header));
-    size_t pubkeys_size = header->pubkeys_length * PUBKEY_SIZE;
+int parse_pubkeys(Parser* parser, size_t  num_pubkeys, const Pubkey** pubkeys) {
+    size_t pubkeys_size = num_pubkeys * PUBKEY_SIZE;
     BAIL_IF(check_buffer_length(parser, pubkeys_size));
     *pubkeys = (const Pubkey*) parser->buffer;
     advance(parser, pubkeys_size);
@@ -138,24 +134,50 @@ int parse_version(Parser* parser, MessageHeader* header) {
 
 int parse_message_header(Parser* parser, MessageHeader* header) {
     BAIL_IF(parse_version(parser, header));
-    BAIL_IF(parse_pubkeys(parser, &header->pubkeys_header, &header->pubkeys));
+    BAIL_IF(parse_pubkeys_header(parser, &header->pubkeys_header));
+    BAIL_IF(parse_pubkeys(parser, header->pubkeys_header.pubkeys_length, &header->pubkeys));
     BAIL_IF(parse_blockhash(parser, &header->blockhash));
     BAIL_IF(parse_length(parser, &header->instructions_length));
     return 0;
 }
 
+int parse_offchain_message_application_domain(
+    Parser* parser,
+    const OffchainMessageApplicationDomain** app_domain
+) {
+    BAIL_IF(check_buffer_length(parser, OFFCHAIN_MESSAGE_APPLICATION_DOMAIN_LENGTH));
+    *app_domain = (const OffchainMessageApplicationDomain*) parser->buffer;
+    advance(parser, OFFCHAIN_MESSAGE_APPLICATION_DOMAIN_LENGTH);
+    return 0;
+}
+
+/**
+ * Field	    Start offset	        Length (bytes)
+ * Signing Domain	0x00	                    16
+ * Header version	0x10	                    1
+ * Application domain	0x11	                    32
+ * Message format	0x31	                    1
+ * Signer count	        0x32	                    1
+ * Signers	        0x33	                    SIGNER_COUNT * 32
+ * Message length	0x33 + SIGNER_CNT * 32	    2
+ */
 int parse_offchain_message_header(Parser* parser, OffchainMessageHeader* header) {
-    const size_t domain_len = strlen(OFFCHAIN_MESSAGE_SIGNING_DOMAIN);
+    const size_t domain_len = OFFCHAIN_MESSAGE_SIGNING_DOMAIN_LENGTH;
     BAIL_IF(check_buffer_length(parser, domain_len));
     int res;
-    if ((res = memcmp(OFFCHAIN_MESSAGE_SIGNING_DOMAIN, parser->buffer, domain_len)) != 0) {
+    if ((res = memcmp((const void*)&offchain_message_signing_domain, parser->buffer, domain_len)) != 0) {
         return res;
     }
-    advance(parser, domain_len);
-
-    BAIL_IF(parse_u8(parser, &header->version));
-    BAIL_IF(parse_u8(parser, &header->format));
-    BAIL_IF(parse_u16(parser, &header->length));
+    advance(parser, domain_len);//Signing domain - 16 bytes
+
+    BAIL_IF(parse_u8(parser, &header->version));// Header version
+    BAIL_IF(parse_offchain_message_application_domain(parser, &header->application_domain));
+    BAIL_IF(parse_u8(parser, &header->format));// Message format
+    uint8_t signers_length = 0;
+    BAIL_IF(parse_u8(parser, &signers_length));// Signer count
+    header->signers_length = signers_length;
+    BAIL_IF(parse_pubkeys(parser, header->signers_length, &header->signers));
+    BAIL_IF(parse_u16(parser, &header->length));// Message length
     return 0;
 }
 

diff --git a/libsol/parser_test.c b/libsol/parser_test.c
@@ -1,6 +1,9 @@
+#include "common_byte_strings.h"
 #include "instruction.h"
 #include "parser.c"
+#include "sol/parser.h"
 #include "sol/printer.h"
+#include "sol/offchain_message_signing.h"
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
@@ -246,22 +249,23 @@ void test_parse_pubkeys_header() {
 }
 
 void test_parse_pubkeys() {
-    uint8_t message[PUBKEY_SIZE + 4] = {1, 2, 3, 1, 42};
+    uint8_t num_pubkeys = 1;
+    uint8_t message[] = {BYTES32_BS58_2};
     Parser parser = {message, sizeof(message)};
-    PubkeysHeader header;
     const Pubkey* pubkeys;
-    assert(parse_pubkeys(&parser, &header, &pubkeys) == 0);
+    assert(parse_pubkeys(&parser, num_pubkeys, &pubkeys) == 0);
     assert(parser_is_empty(&parser));
-    assert(parser.buffer == message + PUBKEY_SIZE + 4);
-    assert(pubkeys->data[0] == 42);
+    assert(parser.buffer == message + ARRAY_LEN(message));
+    const Pubkey expected_pubkey = {{BYTES32_BS58_2}};
+    assert_pubkey_equal(&pubkeys[0], &expected_pubkey);
 }
 
 void test_parse_pubkeys_too_short() {
-    uint8_t message[] = {1, 2, 3, 1};
+    uint8_t num_pubkeys = 1;
+    uint8_t message[] = {num_pubkeys};
     Parser parser = {message, sizeof(message)};
-    PubkeysHeader header;
     const Pubkey* pubkeys;
-    assert(parse_pubkeys(&parser, &header, &pubkeys) == 1);
+    assert(parse_pubkeys(&parser, num_pubkeys, &pubkeys) == 1);
 }
 
 void test_parse_hash() {
@@ -320,6 +324,71 @@ void test_parser_is_empty() {
     assert(parser_is_empty(&empty));
 }
 
+#define TEST_OFFCHAIN_MESSAGE /* "test message" */                        \
+    0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+
+#define OFFCHAIN_MESSAGE_SIGNING_DOMAIN_CHANGED \
+    0x00, 0xaa, 0xbb, 0xcc, 0x00, 0xaa, 0xbb, 0xcc, 0x00, 0xaa, 0xbb, 0xcc
+
+void test_parse_offline_message_header_invalid_sgn_domain(){
+    uint8_t test_message[] = {TEST_OFFCHAIN_MESSAGE};
+    uint16_t message_length = ARRAY_LEN(test_message);
+    uint8_t message_length0 = message_length & 0x00ff;
+    uint8_t message_length1 = (message_length & 0xff00) >> 8;
+    uint8_t buf[] = {
+        OFFCHAIN_MESSAGE_SIGNING_DOMAIN_CHANGED,
+        0,
+        BYTES32_BS58_2,
+        0,
+        1,
+        BYTES32_BS58_3,
+        message_length0, message_length1,
+        TEST_OFFCHAIN_MESSAGE
+    };
+
+    Parser parser = {buf, ARRAY_LEN(buf)};
+    struct OffchainMessageHeader header;
+    //Parse header should return error - invalid signing domain
+    assert(parse_offchain_message_header(&parser, &header) > 0);
+}
+
+
+void test_parse_offline_message_header() {
+    uint8_t test_message[] = {TEST_OFFCHAIN_MESSAGE};
+    uint16_t message_length = ARRAY_LEN(test_message);
+    uint8_t message_length0 = message_length & 0x00ff;
+    uint8_t message_length1 = (message_length & 0xff00) >> 8;
+    uint8_t buf[] = {
+        OFFCHAIN_MESSAGE_SIGNING_DOMAIN,
+        0,
+        BYTES32_BS58_2,
+        0,
+        1,
+        BYTES32_BS58_3,
+        message_length0, message_length1,
+        TEST_OFFCHAIN_MESSAGE
+    };
+
+    Parser parser = {buf, ARRAY_LEN(buf)};
+    struct OffchainMessageHeader header;
+    assert(parse_offchain_message_header(&parser, &header) == 0);
+    assert(header.version == 0);
+    const OffchainMessageApplicationDomain expected_application_domain =
+        {{BYTES32_BS58_2}};
+    assert(memcmp(
+        header.application_domain,
+        &expected_application_domain,
+        OFFCHAIN_MESSAGE_APPLICATION_DOMAIN_LENGTH
+    ) == 0);
+    assert(header.format == 0);
+    assert(header.signers_length == 1);
+    const Pubkey expected_signer = {{BYTES32_BS58_3}};
+    assert_pubkey_equal(&header.signers[0], &expected_signer);
+    assert(memcmp(parser.buffer, test_message, parser.buffer_length) == 0);
+    advance(&parser, message_length);
+    assert(parser_is_empty(&parser));
+}
+
 int main() {
     test_parse_u8();
     test_parse_u8_too_short();
@@ -340,6 +409,8 @@ int main() {
     test_parse_data_too_short();
     test_parse_instruction();
     test_parser_is_empty();
+    test_parse_offline_message_header_invalid_sgn_domain();
+    test_parse_offline_message_header();
 
     printf("passed\n");
     return 0;