Blind sign

app/Makefile

@@ -40,7 +40,7 @@ DEFINES += PRODUCTION_BUILD=$(PRODUCTION_BUILD)
 
 include $(CURDIR)/../deps/ledger-zxlib/makefiles/Makefile.app_testing
 
-DEFINES += REVIEW_SCREEN_ENABLED SHORTCUT_MODE_ENABLED
+DEFINES += APP_BLINDSIGN_MODE_ENABLED
 
 ifndef COIN
 COIN=ALGO

app/Makefile.version

@@ -1,6 +1,6 @@
 # This is the `transaction_version` field of `Runtime`
 APPVERSION_M=2
 # This is the `spec_version` field of `Runtime`
-APPVERSION_N=1
+APPVERSION_N=2
 # This is the patch version of this release
-APPVERSION_P=14
+APPVERSION_P=0

app/src/apdu_handler.c

@@ -29,6 +29,7 @@
 #include "addr.h"
 #include "crypto.h"
 #include "coin.h"
+#include "parser.h"
 #include "zxmacros.h"
 
 static bool tx_initialized = false;
@@ -151,6 +152,10 @@ __Z_INLINE void handle_sign_msgpack(volatile uint32_t *flags, volatile uint32_t
         int error_msg_length = strlen(error_msg);
         memcpy(G_io_apdu_buffer, error_msg, error_msg_length);
         *tx += (error_msg_length);
+        if (strcmp(error_msg, parser_getErrorDescription(parser_blindsign_mode_required)) == 0) {
+            *flags |= IO_ASYNCH_REPLY;
+            view_blindsign_error_show();
+        }
         THROW(APDU_CODE_DATA_INVALID);
     }
 

app/src/common/parser_common.h

@@ -36,6 +36,8 @@ typedef enum {
     parser_display_idx_out_of_range,
     parser_display_page_out_of_range,
     parser_unexpected_error,
+    parser_blindsign_mode_required,
+
     // Coin generic
     parser_unexpected_type,
     parser_unexpected_method,

app/src/parser_impl.c

@@ -16,6 +16,7 @@
 
 #include "parser_impl.h"
 #include "msgpack.h"
+#include "app_mode.h"
 
 static uint8_t num_items;
 static uint8_t common_num_items;
@@ -40,6 +41,24 @@ static parser_error_t _findKey(parser_context_t *c, const char *key);
         counter++;                              \
     }
 
+#define DISPLAY_APP_ITEM(appIdx, len, counter, v)   \
+    if (!app_mode_blindsign()) {                    \
+        for(uint8_t j = 0; j < len; j++) {          \
+            CHECK_ERROR(addItem(appIdx))            \
+            counter++;                              \
+        }                                           \
+    }
+
+#define DISPLAY_COMMON_ITEM(appIdx, len, counter, v)        \
+    if (v->type == TX_APPLICATION && !app_mode_expert()) {  \
+        if (appIdx == IDX_COMMON_SENDER ||                  \
+            appIdx == IDX_COMMON_REKEY_TO) {                \
+            DISPLAY_ITEM(appIdx, len, counter)              \
+        }                                                   \
+    } else {                                                \
+        DISPLAY_ITEM(appIdx, len, counter)                  \
+    }
+
 parser_error_t parser_init_context(parser_context_t *ctx,
                                    const uint8_t *buffer,
                                    uint16_t bufferSize) {
@@ -773,44 +792,44 @@ static parser_error_t _readTxCommonParams(parser_context_t *c, parser_tx_t *v)
 
     CHECK_ERROR(_findKey(c, KEY_COMMON_SENDER))
     CHECK_ERROR(_readBinFixed(c, v->sender, sizeof(v->sender)))
-    DISPLAY_ITEM(IDX_COMMON_SENDER, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_SENDER, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_LEASE) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->lease, sizeof(v->lease)))
-        DISPLAY_ITEM(IDX_COMMON_LEASE, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_LEASE, 1, common_num_items, v)
     }
 
     if (_findKey(c, KEY_COMMON_REKEY) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->rekey, sizeof(v->rekey)))
-        DISPLAY_ITEM(IDX_COMMON_REKEY_TO, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_REKEY_TO, 1, common_num_items, v)
     }
 
     v->fee = 0;
     if (_findKey(c, KEY_COMMON_FEE) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &v->fee))
     }
-    DISPLAY_ITEM(IDX_COMMON_FEE, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_FEE, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_GEN_ID) == parser_ok) {
         CHECK_ERROR(_readString(c, (uint8_t*)v->genesisID, sizeof(v->genesisID)))
-        DISPLAY_ITEM(IDX_COMMON_GEN_ID, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_GEN_ID, 1, common_num_items, v)
     }
 
     CHECK_ERROR(_findKey(c, KEY_COMMON_GEN_HASH))
     CHECK_ERROR(_readBinFixed(c, v->genesisHash, sizeof(v->genesisHash)))
-    DISPLAY_ITEM(IDX_COMMON_GEN_HASH, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_GEN_HASH, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_GROUP_ID) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->groupID, sizeof(v->groupID)))
-        DISPLAY_ITEM(IDX_COMMON_GROUP_ID, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_GROUP_ID, 1, common_num_items, v)
     }
 
     if (_findKey(c, KEY_COMMON_NOTE) == parser_ok) {
         CHECK_ERROR(_readBinSize(c, &v->note_len))
         if(v->note_len > MAX_NOTE_LEN) {
             return parser_unexpected_value;
         }
-        DISPLAY_ITEM(IDX_COMMON_NOTE, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_NOTE, 1, common_num_items, v)
     }
 
     // First and Last valid won't be display --> don't count them
@@ -1049,31 +1068,31 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
     if (_findKey(c, KEY_APP_ID) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &application->id))
     }
-    DISPLAY_ITEM(IDX_APP_ID, 1, tx_num_items)
+    DISPLAY_APP_ITEM(IDX_APP_ID, 1, tx_num_items, v)
 
     if (_findKey(c, KEY_APP_ONCOMPLETION) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &application->oncompletion))
     }
-    DISPLAY_ITEM(IDX_ON_COMPLETION, 1, tx_num_items)
+    DISPLAY_APP_ITEM(IDX_ON_COMPLETION, 1, tx_num_items, v)
 
     if (_findKey(c, KEY_APP_BOXES) == parser_ok) {
         CHECK_ERROR(_readBoxes(c, application->boxes, &application->num_boxes))
-        DISPLAY_ITEM(IDX_BOXES, application->num_boxes, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_BOXES, application->num_boxes, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_FOREIGN_APPS) == parser_ok) {
         CHECK_ERROR(_readArrayU64(c, application->foreign_apps, &application->num_foreign_apps, MAX_FOREIGN_APPS))
-        DISPLAY_ITEM(IDX_FOREIGN_APP, application->num_foreign_apps, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_FOREIGN_APP, application->num_foreign_apps, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_FOREIGN_ASSETS) == parser_ok) {
         CHECK_ERROR(_readArrayU64(c, application->foreign_assets, &application->num_foreign_assets, MAX_FOREIGN_ASSETS))
-        DISPLAY_ITEM(IDX_FOREIGN_ASSET, application->num_foreign_assets, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_FOREIGN_ASSET, application->num_foreign_assets, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_ACCOUNTS) == parser_ok) {
         CHECK_ERROR(_verifyAccounts(c, &application->num_accounts, MAX_ACCT))
-        DISPLAY_ITEM(IDX_ACCOUNTS, application->num_accounts, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_ACCOUNTS, application->num_accounts, tx_num_items, v)
     }
 
     if(application->num_accounts + application->num_foreign_apps + application->num_foreign_assets > ACCT_FOREIGN_LIMIT) {
@@ -1082,7 +1101,7 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
 
     if (_findKey(c, KEY_APP_ARGS) == parser_ok) {
         CHECK_ERROR(_verifyAppArgs(c, application->app_args_len, &application->num_app_args, MAX_ARG))
-        DISPLAY_ITEM(IDX_APP_ARGS, application->num_app_args, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_APP_ARGS, application->num_app_args, tx_num_items, v)
     }
 
     uint16_t app_args_total_len = 0;
@@ -1095,30 +1114,30 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
 
     if (_findKey(c, KEY_APP_GLOBAL_SCHEMA) == parser_ok) {
         CHECK_ERROR(_readStateSchema(c, &application->global_schema))
-        DISPLAY_ITEM(IDX_GLOBAL_SCHEMA, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_GLOBAL_SCHEMA, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_LOCAL_SCHEMA) == parser_ok) {
         CHECK_ERROR(_readStateSchema(c, &application->local_schema))
-        DISPLAY_ITEM(IDX_LOCAL_SCHEMA, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_LOCAL_SCHEMA, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_EXTRA_PAGES) == parser_ok) {
         CHECK_ERROR(_readUInt8(c, &application->extra_pages))
         if (application->extra_pages > 3){
             return parser_too_many_extra_pages;
         }
-        DISPLAY_ITEM(IDX_EXTRA_PAGES, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_EXTRA_PAGES, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_APROG_LEN) == parser_ok) {
         CHECK_ERROR(_getPointerBin(c, &application->aprog, &application->aprog_len))
-        DISPLAY_ITEM(IDX_APPROVE, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_APPROVE, 1, tx_num_items, v)
     }
 
    if (_findKey(c, KEY_APP_CPROG_LEN) == parser_ok) {
        CHECK_ERROR(_getPointerBin(c, &application->cprog, &application->cprog_len))
-       DISPLAY_ITEM(IDX_CLEAR, 1, tx_num_items)
+       DISPLAY_APP_ITEM(IDX_CLEAR, 1, tx_num_items, v)
    }
 
     if (application->id == 0 && application->cprog_len + application->aprog_len > PAGE_LEN *(1+application->extra_pages)){
@@ -1163,7 +1182,17 @@ parser_error_t _read(parser_context_t *c, parser_tx_t *v)
         CHECK_ERROR(_readTxAssetConfig(c, v))
         break;
     case TX_APPLICATION:
+        #if defined(TARGET_NANOS) || defined(TARGET_NANOS2) || defined(TARGET_NANOX) || defined(TARGET_STAX) || defined(TARGET_FLEX)
+        if (!app_mode_blindsign() && !app_mode_expert()) {
+            return parser_blindsign_mode_required;
+        }
+        CHECK_ERROR(_readTxApplication(c, v))
+        if (app_mode_expert() && !app_mode_blindsign()) {
+            app_mode_skip_blindsign_ui();
+        }
+        #else
         CHECK_ERROR(_readTxApplication(c, v))
+        #endif
         break;
     default:
         return parser_unknown_transaction;
@@ -1222,6 +1251,8 @@ const char *parser_getErrorDescription(parser_error_t err) {
             return "display page out of range";
         case parser_unexpected_error:
             return "Unexpected error in parser";
+        case parser_blindsign_mode_required:
+            return "Blind signing mode required";
         case parser_unexpected_type:
             return "Unexpected type";
         case parser_unexpected_method:

tests_zemu/package.json

@@ -15,13 +15,15 @@
   ],
   "scripts": {
     "clean": "ts-node tests/pullImageKillOld.ts",
-    "test": "yarn clean && jest --maxConcurrency 2"
+    "test": "yarn clean && jest --maxConcurrency 2",
+    "try": "node try.mjs"
   },
   "dependencies": {
     "@zondax/ledger-algorand": "../js",
-    "@zondax/zemu": "^0.51.0"
+    "@zondax/zemu": "^0.53.0"
   },
   "devDependencies": {
+    "@ledgerhq/hw-transport-node-hid": "^6.29.5",
     "@types/jest": "^29.4.0",
     "@types/ledgerhq__hw-transport": "^4.21.4",
     "@typescript-eslint/eslint-plugin": "^7.17.0",