common/autoboot.c

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