Blindsign flow

app/Makefile

@@ -38,6 +38,7 @@ endif
 
 # Add the PRODUCTION_BUILD definition to the compiler flags
 DEFINES += PRODUCTION_BUILD=$(PRODUCTION_BUILD)
+DEFINES += APP_BLINDSIGN_MODE_ENABLED
 
 include $(CURDIR)/../deps/ledger-zxlib/makefiles/Makefile.app_testing
 

app/src/apdu_handler.c

@@ -383,11 +383,10 @@ handleSign(volatile uint32_t *flags, volatile uint32_t *tx, uint32_t rx)
     }
     CHECK_APP_CANARY()
 
-    const char *error_msg = tx_parse();
+    uint8_t error_code;
+    const char *error_msg = tx_parse(&error_code);
     CHECK_APP_CANARY()
 
-
-
     if (error_msg != NULL) {
         const int error_msg_length = strnlen(error_msg, sizeof(G_io_apdu_buffer));
         MEMCPY(G_io_apdu_buffer, error_msg, error_msg_length);
@@ -432,13 +431,18 @@ handleSignRawBytes(volatile uint32_t *flags, volatile uint32_t *tx, uint32_t rx)
 
     CHECK_APP_CANARY()
 
-    const char *error_msg = tx_parse();
+    uint8_t error_code;
+    const char *error_msg = tx_parse(&error_code);
     CHECK_APP_CANARY()
 
     if (error_msg != NULL) {
         const int error_msg_length = strnlen(error_msg, sizeof(G_io_apdu_buffer));
         MEMCPY(G_io_apdu_buffer, error_msg, error_msg_length);
         *tx += (error_msg_length);
+        if (error_code == parser_blindsign_required) {
+            *flags |= IO_ASYNCH_REPLY;
+            view_blindsign_error_show();
+        }
         THROW(APDU_CODE_DATA_INVALID);
     }
 
@@ -460,13 +464,18 @@ handleSignEth(volatile uint32_t *flags, volatile uint32_t *tx, uint32_t rx)
 
     CHECK_APP_CANARY()
 
-    const char *error_msg = tx_parse();
+    uint8_t error_code;
+    const char *error_msg = tx_parse(&error_code);
     CHECK_APP_CANARY()
 
     if (error_msg != NULL) {
         const int error_msg_length = strnlen(error_msg, sizeof(G_io_apdu_buffer));
         MEMCPY(G_io_apdu_buffer, error_msg, error_msg_length);
         *tx += (error_msg_length);
+        if (error_code == parser_blindsign_required) {
+            *flags |= IO_ASYNCH_REPLY;
+            view_blindsign_error_show();
+        }
         THROW(APDU_CODE_DATA_INVALID);
     }
 

app/src/common/parser_common.h

@@ -70,6 +70,7 @@ typedef enum {
   parser_invalid_prefix,
   // Customs
   parser_expert_mode_required,
+  parser_blindsign_required,
 } parser_error_t;
 
 // Define the three types

app/src/common/tx.c

@@ -96,7 +96,7 @@ uint8_t *tx_get_buffer() {
     return buffering_get_buffer()->data;
 }
 
-const char *tx_parse() {
+const char *tx_parse(uint8_t *error_code) {
     uint8_t err = parser_parse(
             &ctx_parsed_tx,
             tx_get_buffer(),
@@ -106,6 +106,7 @@ const char *tx_parse() {
         return parser_getErrorDescription(err);
 
     err = parser_validate(&ctx_parsed_tx);
+    *error_code = err;
     CHECK_APP_CANARY()
 
     if (err != parser_ok)

app/src/common/tx.h

@@ -54,7 +54,7 @@ uint8_t *tx_get_buffer();
 /// Parse message stored in transaction buffer
 /// This function should be called as soon as full buffer data is loaded.
 /// \return It returns NULL if data is valid or error message otherwise.
-const char *tx_parse();
+const char *tx_parse(uint8_t *error_code);
 
 /// Return the number of items in the transaction
 zxerr_t tx_getNumItems(uint8_t *num_items);

app/src/parser.c

@@ -78,6 +78,7 @@ parser_error_t parser_parse(parser_context_t *ctx, const uint8_t *data,
   switch (ctx->tx_type) {
   case fil_tx: {
     CHECK_PARSER_ERR(parser_init(ctx, data, dataLen))
+    app_mode_skip_blindsign_ui(); 
     return _read(ctx, &(parser_tx_obj.base_tx));
   }
   case eth_tx: {
@@ -86,12 +87,13 @@ parser_error_t parser_parse(parser_context_t *ctx, const uint8_t *data,
   }
   case clientdeal_tx: {
     CHECK_PARSER_ERR(parser_init(ctx, data, dataLen))
+    app_mode_skip_blindsign_ui(); 
     return _readClientDeal(ctx, &parser_tx_obj.client_deal_tx);
   }
   case raw_bytes: {
     // Processing raw-bytes is valid only in expert mode
-    if (!app_mode_expert())
-      return parser_expert_mode_required;
+    if (!app_mode_blindsign())
+      return parser_blindsign_required;
 
     return _readRawBytes(ctx, &parser_tx_obj.raw_bytes_tx);
   }

app/src/parser_impl_eth.c

@@ -165,8 +165,8 @@ parser_error_t _readEth(parser_context_t *ctx, eth_tx_t *tx_obj) {
 }
 
 parser_error_t _validateTxEth() {
-    if (!validateERC20(&eth_tx_obj) && !app_mode_expert()) {
-        return parser_unsupported_tx;
+    if (!validateERC20(&eth_tx_obj) && !app_mode_blindsign()) {
+        return parser_blindsign_required;
     }
 
     return parser_ok;
@@ -240,20 +240,15 @@ parser_error_t _getItemEth(const parser_context_t *ctx, uint8_t displayIdx,
         return printERC20(displayIdx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount);
     }
 
-    // Otherwise, check that ExpertMode is enabled
-    if (!app_mode_expert())
-      return parser_unsupported_tx;
+    // Otherwise, check that Blindsign is enabled
+    if (!app_mode_blindsign()) {
+      return parser_blindsign_required;
+    }
 
     if (displayIdx > 1) {
         return parser_display_idx_out_of_range;
     }
 
-    if (displayIdx == 0) {
-        snprintf(outKey, outKeyLen, "Warning:");
-        pageString(outVal, outValLen, "Blind-signing EVM Tx", pageIdx, pageCount);
-        return parser_ok;
-    }
-
     // we need to get keccak hash of the transaction data
     uint8_t hash[32] = {0};
     keccak_digest(ctx->buffer, ctx->bufferLen, hash, 32);
@@ -287,8 +282,8 @@ parser_error_t _getNumItemsEth(uint8_t* numItems) {
         return parser_ok;
     }
 
-    // Warning message and the eth transaction hash for now.
-    *numItems = 2;
+    // Eth transaction hash.
+    *numItems = 1;
     return parser_ok;
 }
 

app/src/parser_raw_bytes.c

@@ -117,8 +117,8 @@ parser_error_t _validateRawBytes(__Z_UNUSED const parser_context_t *ctx) {
 }
 
 uint8_t _getNumItemsRawBytes(__Z_UNUSED const parser_context_t *ctx) {
-  // Warning message and raw-bytes data hash as an hex string
-  return 2;
+  // Raw-bytes data hash as an hex string
+  return 1;
 }
 
 parser_error_t _getItemRawBytes(__Z_UNUSED const parser_context_t *ctx,
@@ -127,15 +127,15 @@ parser_error_t _getItemRawBytes(__Z_UNUSED const parser_context_t *ctx,
                                 uint16_t outValLen, uint8_t pageIdx,
                                 uint8_t *pageCount) {
 
-  if (displayIdx > 1)
+  if (displayIdx > 1) {
     return parser_display_idx_out_of_range;
-
-  if (displayIdx == 0) {
-    snprintf(outKey, outKeyLen, "Warning:");
-    pageString(outVal, outValLen, "Signing Raw-bytes data", pageIdx, pageCount);
-    return parser_ok;
   }
 
+    // Check that Blindsign is enabled
+    if (!app_mode_blindsign()) {
+      return parser_blindsign_required;
+    }
+
   // get the hash of the buffer
   uint8_t hex[BLAKE2B_256_SIZE * 2 + 1] = {0};