common/autoboot.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #include <common.h>
   8 #include <autoboot.h>
   9 #include <bootretry.h>
  10 #include <cli.h>
  11 #include <console.h>
  12 #include <fdtdec.h>
  13 #include <hash.h>
  14 #include <menu.h>
  15 #include <post.h>
  16 #include <u-boot/sha256.h>
  17 #include <bootcount.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 #define MAX_DELAY_STOP_STR 32
  22
  23 #ifndef DEBUG_BOOTKEYS
  24 #define DEBUG_BOOTKEYS 0
  25 #endif
  26 #define debug_bootkeys(fmt, args...)            \
  27         debug_cond(DEBUG_BOOTKEYS, fmt, ##args)
  28
  29 /* Stored value of bootdelay, used by autoboot_command() */
  30 static int stored_bootdelay;
  31 static int menukey;
  32
  33 #ifdef CONFIG_AUTOBOOT_ENCRYPTION
  34 #define AUTOBOOT_STOP_STR_SHA256 CONFIG_AUTOBOOT_STOP_STR_SHA256
  35 #else
  36 #define AUTOBOOT_STOP_STR_SHA256 ""
  37 #endif
  38
  39 #ifdef CONFIG_USE_AUTOBOOT_MENUKEY
  40 #define AUTOBOOT_MENUKEY CONFIG_USE_AUTOBOOT_MENUKEY
  41 #else
  42 #define AUTOBOOT_MENUKEY 0
  43 #endif
  44
  45 /*
  46  * Use a "constant-length" time compare function for this
  47  * hash compare:
  48  *
  49  * https://crackstation.net/hashing-security.htm
  50  */
  51 static int slow_equals(u8 *a, u8 *b, int len)
  52 {
  53         int diff = 0;
  54         int i;
  55
  56         for (i = 0; i < len; i++)
  57                 diff |= a[i] ^ b[i];
  58
  59         return diff == 0;
  60 }
  61
  62 /**
  63  * passwd_abort_sha256() - check for a hashed key sequence to abort booting
  64  *
  65  * This checks for the user entering a SHA256 hash within a given time.
  66  *
  67  * @etime: Timeout value ticks (stop when get_ticks() reachs this)
  68  * @return 0 if autoboot should continue, 1 if it should stop
  69  */
  70 static int passwd_abort_sha256(uint64_t etime)
  71 {
  72         const char *sha_env_str = env_get("bootstopkeysha256");
  73         u8 sha_env[SHA256_SUM_LEN];
  74         u8 sha[SHA256_SUM_LEN];
  75         char presskey[MAX_DELAY_STOP_STR];
  76         const char *algo_name = "sha256";
  77         u_int presskey_len = 0;
  78         int abort = 0;
  79         int size = sizeof(sha);
  80         int ret;
  81
  82         if (sha_env_str == NULL)
  83                 sha_env_str = AUTOBOOT_STOP_STR_SHA256;
  84
  85         /*
  86          * Generate the binary value from the environment hash value
  87          * so that we can compare this value with the computed hash
  88          * from the user input
  89          */
  90         ret = hash_parse_string(algo_name, sha_env_str, sha_env);
  91         if (ret) {
  92                 printf("Hash %s not supported!\n", algo_name);
  93                 return 0;
  94         }
  95
  96         /*
  97          * We don't know how long the stop-string is, so we need to
  98          * generate the sha256 hash upon each input character and
  99          * compare the value with the one saved in the environment
 100          */
 101         do {
 102                 if (tstc()) {
 103                         /* Check for input string overflow */
 104                         if (presskey_len >= MAX_DELAY_STOP_STR)
 105                                 return 0;
 106
 107                         presskey[presskey_len++] = getc();
 108
 109                         /* Calculate sha256 upon each new char */
 110                         hash_block(algo_name, (const void *)presskey,
 111                                    presskey_len, sha, &size);
 112
 113                         /* And check if sha matches saved value in env */
 114                         if (slow_equals(sha, sha_env, SHA256_SUM_LEN))
 115                                 abort = 1;
 116                 }
 117         } while (!abort && get_ticks() <= etime);
 118
 119         return abort;
 120 }
 121
 122 /**
 123  * passwd_abort_key() - check for a key sequence to aborted booting
 124  *
 125  * This checks for the user entering a string within a given time.
 126  *
 127  * @etime: Timeout value ticks (stop when get_ticks() reachs this)
 128  * @return 0 if autoboot should continue, 1 if it should stop
 129  */
 130 static int passwd_abort_key(uint64_t etime)
 131 {
 132         int abort = 0;
 133         struct {
 134                 char *str;
 135                 u_int len;
 136                 int retry;
 137         }
 138         delaykey[] = {
 139                 { .str = env_get("bootdelaykey"),  .retry = 1 },
 140                 { .str = env_get("bootstopkey"),   .retry = 0 },
 141         };
 142
 143         char presskey[MAX_DELAY_STOP_STR];
 144         u_int presskey_len = 0;
 145         u_int presskey_max = 0;
 146         u_int i;
 147
 148 #  ifdef CONFIG_AUTOBOOT_DELAY_STR
 149         if (delaykey[0].str == NULL)
 150                 delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
 151 #  endif
 152 #  ifdef CONFIG_AUTOBOOT_STOP_STR
 153         if (delaykey[1].str == NULL)
 154                 delaykey[1].str = CONFIG_AUTOBOOT_STOP_STR;
 155 #  endif
 156
 157         for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
 158                 delaykey[i].len = delaykey[i].str == NULL ?
 159                                     0 : strlen(delaykey[i].str);
 160                 delaykey[i].len = delaykey[i].len > MAX_DELAY_STOP_STR ?
 161                                     MAX_DELAY_STOP_STR : delaykey[i].len;
 162
 163                 presskey_max = presskey_max > delaykey[i].len ?
 164                                     presskey_max : delaykey[i].len;
 165
 166                 debug_bootkeys("%s key:<%s>\n",
 167                                delaykey[i].retry ? "delay" : "stop",
 168                                delaykey[i].str ? delaykey[i].str : "NULL");
 169         }
 170
 171         /* In order to keep up with incoming data, check timeout only
 172          * when catch up.
 173          */
 174         do {
 175                 if (tstc()) {
 176                         if (presskey_len < presskey_max) {
 177                                 presskey[presskey_len++] = getc();
 178                         } else {
 179                                 for (i = 0; i < presskey_max - 1; i++)
 180                                         presskey[i] = presskey[i + 1];
 181
 182                                 presskey[i] = getc();
 183                         }
 184                 }
 185
 186                 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
 187                         if (delaykey[i].len > 0 &&
 188                             presskey_len >= delaykey[i].len &&
 189                                 memcmp(presskey + presskey_len -
 190                                         delaykey[i].len, delaykey[i].str,
 191                                         delaykey[i].len) == 0) {
 192                                         debug_bootkeys("got %skey\n",
 193                                                 delaykey[i].retry ? "delay" :
 194                                                 "stop");
 195
 196                                 /* don't retry auto boot */
 197                                 if (!delaykey[i].retry)
 198                                         bootretry_dont_retry();
 199                                 abort = 1;
 200                         }
 201                 }
 202         } while (!abort && get_ticks() <= etime);
 203
 204         return abort;
 205 }
 206
 207 /***************************************************************************
 208  * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
 209  * returns: 0 -  no key string, allow autoboot 1 - got key string, abort
 210  */
 211 static int abortboot_key_sequence(int bootdelay)
 212 {
 213         int abort;
 214         uint64_t etime = endtick(bootdelay);
 215
 216 #  ifdef CONFIG_AUTOBOOT_PROMPT
 217         /*
 218          * CONFIG_AUTOBOOT_PROMPT includes the %d for all boards.
 219          * To print the bootdelay value upon bootup.
 220          */
 221         printf(CONFIG_AUTOBOOT_PROMPT, bootdelay);
 222 #  endif
 223
 224         if (IS_ENABLED(CONFIG_AUTOBOOT_ENCRYPTION))
 225                 abort = passwd_abort_sha256(etime);
 226         else
 227                 abort = passwd_abort_key(etime);
 228         if (!abort)
 229                 debug_bootkeys("key timeout\n");
 230
 231         return abort;
 232 }
 233
 234 static int abortboot_single_key(int bootdelay)
 235 {
 236         int abort = 0;
 237         unsigned long ts;
 238
 239         printf("Hit any key to stop autoboot: %2d ", bootdelay);
 240
 241         /*
 242          * Check if key already pressed
 243          */
 244         if (tstc()) {   /* we got a key press   */
 245                 (void) getc();  /* consume input        */
 246                 puts("\b\b\b 0");
 247                 abort = 1;      /* don't auto boot      */
 248         }
 249
 250         while ((bootdelay > 0) && (!abort)) {
 251                 --bootdelay;
 252                 /* delay 1000 ms */
 253                 ts = get_timer(0);
 254                 do {
 255                         if (tstc()) {   /* we got a key press   */
 256                                 int key;
 257
 258                                 abort  = 1;     /* don't auto boot      */
 259                                 bootdelay = 0;  /* no more delay        */
 260                                 key = getc(); /* consume input  */
 261                                 if (IS_ENABLED(CONFIG_USE_AUTOBOOT_MENUKEY))
 262                                         menukey = key;
 263                                 break;
 264                         }
 265                         udelay(10000);
 266                 } while (!abort && get_timer(ts) < 1000);
 267
 268                 printf("\b\b\b%2d ", bootdelay);
 269         }
 270
 271         putc('\n');
 272
 273         return abort;
 274 }
 275
 276 static int abortboot(int bootdelay)
 277 {
 278         int abort = 0;
 279
 280         if (bootdelay >= 0) {
 281                 if (IS_ENABLED(CONFIG_AUTOBOOT_KEYED))
 282                         abort = abortboot_key_sequence(bootdelay);
 283                 else
 284                         abort = abortboot_single_key(bootdelay);
 285         }
 286
 287         if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && abort)
 288                 gd->flags &= ~GD_FLG_SILENT;
 289
 290         return abort;
 291 }
 292
 293 static void process_fdt_options(const void *blob)
 294 {
 295 #ifdef CONFIG_SYS_TEXT_BASE
 296         ulong addr;
 297
 298         /* Add an env variable to point to a kernel payload, if available */
 299         addr = fdtdec_get_config_int(gd->fdt_blob, "kernel-offset", 0);
 300         if (addr)
 301                 env_set_addr("kernaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
 302
 303         /* Add an env variable to point to a root disk, if available */
 304         addr = fdtdec_get_config_int(gd->fdt_blob, "rootdisk-offset", 0);
 305         if (addr)
 306                 env_set_addr("rootaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
 307 #endif /* CONFIG_SYS_TEXT_BASE */
 308 }
 309
 310 const char *bootdelay_process(void)
 311 {
 312         char *s;
 313         int bootdelay;
 314
 315         bootcount_inc();
 316
 317         s = env_get("bootdelay");
 318         bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
 319
 320         if (IS_ENABLED(CONFIG_OF_CONTROL))
 321                 bootdelay = fdtdec_get_config_int(gd->fdt_blob, "bootdelay",
 322                                                   bootdelay);
 323
 324         debug("### main_loop entered: bootdelay=%d\n\n", bootdelay);
 325
 326         if (IS_ENABLED(CONFIG_AUTOBOOT_MENU_SHOW))
 327                 bootdelay = menu_show(bootdelay);
 328         bootretry_init_cmd_timeout();
 329
 330 #ifdef CONFIG_POST
 331         if (gd->flags & GD_FLG_POSTFAIL) {
 332                 s = env_get("failbootcmd");
 333         } else
 334 #endif /* CONFIG_POST */
 335         if (bootcount_error())
 336                 s = env_get("altbootcmd");
 337         else
 338                 s = env_get("bootcmd");
 339
 340         if (IS_ENABLED(CONFIG_OF_CONTROL))
 341                 process_fdt_options(gd->fdt_blob);
 342         stored_bootdelay = bootdelay;
 343
 344         return s;
 345 }
 346
 347 void autoboot_command(const char *s)
 348 {
 349         debug("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
 350
 351         if (stored_bootdelay != -1 && s && !abortboot(stored_bootdelay)) {
 352 #if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
 353                 int prev = disable_ctrlc(1);    /* disable Control C checking */
 354 #endif
 355
 356                 run_command_list(s, -1, 0);
 357
 358 #if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
 359                 disable_ctrlc(prev);    /* restore Control C checking */
 360 #endif
 361         }
 362
 363         if (IS_ENABLED(CONFIG_USE_AUTOBOOT_MENUKEY) &&
 364             menukey == AUTOBOOT_MENUKEY) {
 365                 s = env_get("menucmd");
 366                 if (s)
 367                         run_command_list(s, -1, 0);
 368         }
 369 }