LXR uboot/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 <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 <asm/global_data.h>
  23#include <linux/delay.h>
  24#include <u-boot/sha256.h>
  25#include <bootcount.h>
  26#include <crypt.h>
  27
  28DECLARE_GLOBAL_DATA_PTR;
  29
  30#define DELAY_STOP_STR_MAX_LENGTH 64
  31
  32#ifndef DEBUG_BOOTKEYS
  33#define DEBUG_BOOTKEYS 0
  34#endif
  35#define debug_bootkeys(fmt, args...)            \
  36        debug_cond(DEBUG_BOOTKEYS, fmt, ##args)
  37
  38/* Stored value of bootdelay, used by autoboot_command() */
  39static int stored_bootdelay;
  40static int menukey;
  41
  42#if !defined(CONFIG_AUTOBOOT_STOP_STR_CRYPT)
  43#define CONFIG_AUTOBOOT_STOP_STR_CRYPT ""
  44#endif
  45#if !defined(CONFIG_AUTOBOOT_STOP_STR_SHA256)
  46#define CONFIG_AUTOBOOT_STOP_STR_SHA256 ""
  47#endif
  48
  49#ifdef CONFIG_AUTOBOOT_USE_MENUKEY
  50#define AUTOBOOT_MENUKEY CONFIG_AUTOBOOT_MENUKEY
  51#else
  52#define AUTOBOOT_MENUKEY 0
  53#endif
  54
  55/**
  56 * passwd_abort_crypt() - check for a crypt-style hashed key sequence to abort booting
  57 *
  58 * This checks for the user entering a password within a given time.
  59 *
  60 * The entered password is hashed via one of the crypt-style hash methods
  61 * and compared to the pre-defined value from either
  62 *   the environment variable "bootstopkeycrypt"
  63 * or
  64 *   the config value CONFIG_AUTOBOOT_STOP_STR_CRYPT
  65 *
  66 * In case the config value CONFIG_AUTOBOOT_NEVER_TIMEOUT has been enabled
  67 * this function never times out if the user presses the <Enter> key
  68 * before starting to enter the password.
  69 *
  70 * @etime: Timeout value ticks (stop when get_ticks() reachs this)
  71 * @return 0 if autoboot should continue, 1 if it should stop
  72 */
  73static int passwd_abort_crypt(uint64_t etime)
  74{
  75        const char *crypt_env_str = env_get("bootstopkeycrypt");
  76        char presskey[DELAY_STOP_STR_MAX_LENGTH];
  77        u_int presskey_len = 0;
  78        int abort = 0;
  79        int never_timeout = 0;
  80        int err;
  81
  82        if (IS_ENABLED(CONFIG_AUTOBOOT_STOP_STR_ENABLE) && !crypt_env_str)
  83                crypt_env_str = CONFIG_AUTOBOOT_STOP_STR_CRYPT;
  84
  85        if (!crypt_env_str)
  86                return 0;
  87
  88        /* We expect the stop-string to be newline-terminated */
  89        do {
  90                if (tstc()) {
  91                        /* Check for input string overflow */
  92                        if (presskey_len >= sizeof(presskey))
  93                                return 0;
  94
  95                        presskey[presskey_len] = getchar();
  96
  97                        if ((presskey[presskey_len] == '\r') ||
  98                            (presskey[presskey_len] == '\n')) {
  99                                if (IS_ENABLED(CONFIG_AUTOBOOT_NEVER_TIMEOUT) &&
 100                                    !presskey_len) {
 101                                        never_timeout = 1;
 102                                        continue;
 103                                }
 104                                presskey[presskey_len] = '\0';
 105                                err = crypt_compare(crypt_env_str, presskey,
 106                                                    &abort);
 107                                if (err)
 108                                        debug_bootkeys(
 109                                                "crypt_compare() failed with: %s\n",
 110                                                errno_str(err));
 111                                /* you had one chance */
 112                                break;
 113                        } else {
 114                                presskey_len++;
 115                        }
 116                }
 117        } while (never_timeout || get_ticks() <= etime);
 118
 119        return abort;
 120}
 121
 122/*
 123 * Use a "constant-length" time compare function for this
 124 * hash compare:
 125 *
 126 * https://crackstation.net/hashing-security.htm
 127 */
 128static int slow_equals(u8 *a, u8 *b, int len)
 129{
 130        int diff = 0;
 131        int i;
 132
 133        for (i = 0; i < len; i++)
 134                diff |= a[i] ^ b[i];
 135
 136        return diff == 0;
 137}
 138
 139/**
 140 * passwd_abort_sha256() - check for a hashed key sequence to abort booting
 141 *
 142 * This checks for the user entering a SHA256 hash within a given time.
 143 *
 144 * @etime: Timeout value ticks (stop when get_ticks() reachs this)
 145 * @return 0 if autoboot should continue, 1 if it should stop
 146 */
 147static int passwd_abort_sha256(uint64_t etime)
 148{
 149        const char *sha_env_str = env_get("bootstopkeysha256");
 150        u8 sha_env[SHA256_SUM_LEN];
 151        u8 *sha;
 152        char *presskey;
 153        char *c;
 154        const char *algo_name = "sha256";
 155        u_int presskey_len = 0;
 156        int abort = 0;
 157        int size = sizeof(sha);
 158        int ret;
 159
 160        if (sha_env_str == NULL)
 161                sha_env_str = CONFIG_AUTOBOOT_STOP_STR_SHA256;
 162
 163        presskey = malloc_cache_aligned(DELAY_STOP_STR_MAX_LENGTH);
 164        c = strstr(sha_env_str, ":");
 165        if (c && (c - sha_env_str < DELAY_STOP_STR_MAX_LENGTH)) {
 166                /* preload presskey with salt */
 167                memcpy(presskey, sha_env_str, c - sha_env_str);
 168                presskey_len = c - sha_env_str;
 169                sha_env_str = c + 1;
 170        }
 171        /*
 172         * Generate the binary value from the environment hash value
 173         * so that we can compare this value with the computed hash
 174         * from the user input
 175         */
 176        ret = hash_parse_string(algo_name, sha_env_str, sha_env);
 177        if (ret) {
 178                printf("Hash %s not supported!\n", algo_name);
 179                return 0;
 180        }
 181
 182        sha = malloc_cache_aligned(SHA256_SUM_LEN);
 183        size = SHA256_SUM_LEN;
 184        /*
 185         * We don't know how long the stop-string is, so we need to
 186         * generate the sha256 hash upon each input character and
 187         * compare the value with the one saved in the environment
 188         */
 189        do {
 190                if (tstc()) {
 191                        /* Check for input string overflow */
 192                        if (presskey_len >= DELAY_STOP_STR_MAX_LENGTH) {
 193                                free(presskey);
 194                                free(sha);
 195                                return 0;
 196                        }
 197
 198                        presskey[presskey_len++] = getchar();
 199
 200                        /* Calculate sha256 upon each new char */
 201                        hash_block(algo_name, (const void *)presskey,
 202                                   presskey_len, sha, &size);
 203
 204                        /* And check if sha matches saved value in env */
 205                        if (slow_equals(sha, sha_env, SHA256_SUM_LEN))
 206                                abort = 1;
 207                }
 208        } while (!abort && get_ticks() <= etime);
 209
 210        free(presskey);
 211        free(sha);
 212        return abort;
 213}
 214
 215/**
 216 * passwd_abort_key() - check for a key sequence to aborted booting
 217 *
 218 * This checks for the user entering a string within a given time.
 219 *
 220 * @etime: Timeout value ticks (stop when get_ticks() reachs this)
 221 * @return 0 if autoboot should continue, 1 if it should stop
 222 */
 223static int passwd_abort_key(uint64_t etime)
 224{
 225        int abort = 0;
 226        struct {
 227                char *str;
 228                u_int len;
 229                int retry;
 230        }
 231        delaykey[] = {
 232                { .str = env_get("bootdelaykey"),  .retry = 1 },
 233                { .str = env_get("bootstopkey"),   .retry = 0 },
 234        };
 235
 236        char presskey[DELAY_STOP_STR_MAX_LENGTH];
 237        int presskey_len = 0;
 238        int presskey_max = 0;
 239        int i;
 240
 241#  ifdef CONFIG_AUTOBOOT_DELAY_STR
 242        if (delaykey[0].str == NULL)
 243                delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
 244#  endif
 245#  ifdef CONFIG_AUTOBOOT_STOP_STR
 246        if (delaykey[1].str == NULL)
 247                delaykey[1].str = CONFIG_AUTOBOOT_STOP_STR;
 248#  endif
 249
 250        for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
 251                delaykey[i].len = delaykey[i].str == NULL ?
 252                                    0 : strlen(delaykey[i].str);
 253                delaykey[i].len = delaykey[i].len > DELAY_STOP_STR_MAX_LENGTH ?
 254                                    DELAY_STOP_STR_MAX_LENGTH : delaykey[i].len;
 255
 256                presskey_max = presskey_max > delaykey[i].len ?
 257                                    presskey_max : delaykey[i].len;
 258
 259                debug_bootkeys("%s key:<%s>\n",
 260                               delaykey[i].retry ? "delay" : "stop",
 261                               delaykey[i].str ? delaykey[i].str : "NULL");
 262        }
 263
 264        /* In order to keep up with incoming data, check timeout only
 265         * when catch up.
 266         */
 267        do {
 268                if (tstc()) {
 269                        if (presskey_len < presskey_max) {
 270                                presskey[presskey_len++] = getchar();
 271                        } else {
 272                                for (i = 0; i < presskey_max - 1; i++)
 273                                        presskey[i] = presskey[i + 1];
 274
 275                                presskey[i] = getchar();
 276                        }
 277                }
 278
 279                for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
 280                        if (delaykey[i].len > 0 &&
 281                            presskey_len >= delaykey[i].len &&
 282                                memcmp(presskey + presskey_len -
 283                                        delaykey[i].len, delaykey[i].str,
 284                                        delaykey[i].len) == 0) {
 285                                        debug_bootkeys("got %skey\n",
 286                                                delaykey[i].retry ? "delay" :
 287                                                "stop");
 288
 289                                /* don't retry auto boot */
 290                                if (!delaykey[i].retry)
 291                                        bootretry_dont_retry();
 292                                abort = 1;
 293                        }
 294                }
 295        } while (!abort && get_ticks() <= etime);
 296
 297        return abort;
 298}
 299
 300/**
 301 * flush_stdin() - drops all pending characters from stdin
 302 */
 303static void flush_stdin(void)
 304{
 305        while (tstc())
 306                (void)getchar();
 307}
 308
 309/**
 310 * fallback_to_sha256() - check whether we should fall back to sha256
 311 *                        password checking
 312 *
 313 * This checks for the environment variable `bootstopusesha256` in case
 314 * sha256-fallback has been enabled via the config setting
 315 * `AUTOBOOT_SHA256_FALLBACK`.
 316 *
 317 * @return `false` if we must not fall-back, `true` if plain sha256 should be tried
 318 */
 319static bool fallback_to_sha256(void)
 320{
 321        if (IS_ENABLED(CONFIG_AUTOBOOT_SHA256_FALLBACK))
 322                return env_get_yesno("bootstopusesha256") == 1;
 323        else if (IS_ENABLED(CONFIG_CRYPT_PW))
 324                return false;
 325        else
 326                return true;
 327}
 328
 329/***************************************************************************
 330 * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
 331 * returns: 0 -  no key string, allow autoboot 1 - got key string, abort
 332 */
 333static int abortboot_key_sequence(int bootdelay)
 334{
 335        int abort;
 336        uint64_t etime = endtick(bootdelay);
 337
 338        if (IS_ENABLED(CONFIG_AUTOBOOT_FLUSH_STDIN))
 339                flush_stdin();
 340#  ifdef CONFIG_AUTOBOOT_PROMPT
 341        /*
 342         * CONFIG_AUTOBOOT_PROMPT includes the %d for all boards.
 343         * To print the bootdelay value upon bootup.
 344         */
 345        printf(CONFIG_AUTOBOOT_PROMPT, bootdelay);
 346#  endif
 347
 348        if (IS_ENABLED(CONFIG_AUTOBOOT_ENCRYPTION)) {
 349                if (IS_ENABLED(CONFIG_CRYPT_PW) && !fallback_to_sha256())
 350                        abort = passwd_abort_crypt(etime);
 351                else
 352                        abort = passwd_abort_sha256(etime);
 353        } else {
 354                abort = passwd_abort_key(etime);
 355        }
 356        if (!abort)
 357                debug_bootkeys("key timeout\n");
 358
 359        return abort;
 360}
 361
 362static int abortboot_single_key(int bootdelay)
 363{
 364        int abort = 0;
 365        unsigned long ts;
 366
 367        printf("Hit any key to stop autoboot: %2d ", bootdelay);
 368
 369        /*
 370         * Check if key already pressed
 371         */
 372        if (tstc()) {   /* we got a key press   */
 373                getchar();      /* consume input        */
 374                puts("\b\b\b 0");
 375                abort = 1;      /* don't auto boot      */
 376        }
 377
 378        while ((bootdelay > 0) && (!abort)) {
 379                --bootdelay;
 380                /* delay 1000 ms */
 381                ts = get_timer(0);
 382                do {
 383                        if (tstc()) {   /* we got a key press   */
 384                                int key;
 385
 386                                abort  = 1;     /* don't auto boot      */
 387                                bootdelay = 0;  /* no more delay        */
 388                                key = getchar();/* consume input        */
 389                                if (IS_ENABLED(CONFIG_AUTOBOOT_USE_MENUKEY))
 390                                        menukey = key;
 391                                break;
 392                        }
 393                        udelay(10000);
 394                } while (!abort && get_timer(ts) < 1000);
 395
 396                printf("\b\b\b%2d ", bootdelay);
 397        }
 398
 399        putc('\n');
 400
 401        return abort;
 402}
 403
 404static int abortboot(int bootdelay)
 405{
 406        int abort = 0;
 407
 408        if (bootdelay >= 0) {
 409                if (autoboot_keyed())
 410                        abort = abortboot_key_sequence(bootdelay);
 411                else
 412                        abort = abortboot_single_key(bootdelay);
 413        }
 414
 415        if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && abort)
 416                gd->flags &= ~GD_FLG_SILENT;
 417
 418        return abort;
 419}
 420
 421static void process_fdt_options(const void *blob)
 422{
 423#ifdef CONFIG_SYS_TEXT_BASE
 424        ulong addr;
 425
 426        /* Add an env variable to point to a kernel payload, if available */
 427        addr = fdtdec_get_config_int(gd->fdt_blob, "kernel-offset", 0);
 428        if (addr)
 429                env_set_addr("kernaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
 430
 431        /* Add an env variable to point to a root disk, if available */
 432        addr = fdtdec_get_config_int(gd->fdt_blob, "rootdisk-offset", 0);
 433        if (addr)
 434                env_set_addr("rootaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
 435#endif /* CONFIG_SYS_TEXT_BASE */
 436}
 437
 438const char *bootdelay_process(void)
 439{
 440        char *s;
 441        int bootdelay;
 442
 443        bootcount_inc();
 444
 445        s = env_get("bootdelay");
 446        bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
 447
 448        if (IS_ENABLED(CONFIG_OF_CONTROL))
 449                bootdelay = fdtdec_get_config_int(gd->fdt_blob, "bootdelay",
 450                                                  bootdelay);
 451
 452        debug("### main_loop entered: bootdelay=%d\n\n", bootdelay);
 453
 454        if (IS_ENABLED(CONFIG_AUTOBOOT_MENU_SHOW))
 455                bootdelay = menu_show(bootdelay);
 456        bootretry_init_cmd_timeout();
 457
 458#ifdef CONFIG_POST
 459        if (gd->flags & GD_FLG_POSTFAIL) {
 460                s = env_get("failbootcmd");
 461        } else
 462#endif /* CONFIG_POST */
 463        if (bootcount_error())
 464                s = env_get("altbootcmd");
 465        else
 466                s = env_get("bootcmd");
 467
 468        if (IS_ENABLED(CONFIG_OF_CONTROL))
 469                process_fdt_options(gd->fdt_blob);
 470        stored_bootdelay = bootdelay;
 471
 472        return s;
 473}
 474
 475void autoboot_command(const char *s)
 476{
 477        debug("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
 478
 479        if (s && (stored_bootdelay == -2 ||
 480                 (stored_bootdelay != -1 && !abortboot(stored_bootdelay)))) {
 481                bool lock;
 482                int prev;
 483
 484                lock = autoboot_keyed() &&
 485                        !IS_ENABLED(CONFIG_AUTOBOOT_KEYED_CTRLC);
 486                if (lock)
 487                        prev = disable_ctrlc(1); /* disable Ctrl-C checking */
 488
 489                run_command_list(s, -1, 0);
 490
 491                if (lock)
 492                        disable_ctrlc(prev);    /* restore Ctrl-C checking */
 493        }
 494
 495        if (IS_ENABLED(CONFIG_AUTOBOOT_USE_MENUKEY) &&
 496            menukey == AUTOBOOT_MENUKEY) {
 497                s = env_get("menucmd");
 498                if (s)
 499                        run_command_list(s, -1, 0);
 500        }
 501}
 502