test/py/tests/test_vboot.py

   1 # SPDX-License-Identifier:      GPL-2.0+
   2 # Copyright (c) 2016, Google Inc.
   3 #
   4 # U-Boot Verified Boot Test
   5
   6 """
   7 This tests verified boot in the following ways:
   8
   9 For image verification:
  10 - Create FIT (unsigned) with mkimage
  11 - Check that verification shows that no keys are verified
  12 - Sign image
  13 - Check that verification shows that a key is now verified
  14
  15 For configuration verification:
  16 - Corrupt signature and check for failure
  17 - Create FIT (with unsigned configuration) with mkimage
  18 - Check that image verification works
  19 - Sign the FIT and mark the key as 'required' for verification
  20 - Check that image verification works
  21 - Corrupt the signature
  22 - Check that image verification no-longer works
  23
  24 For pre-load header verification:
  25 - Create FIT image with a pre-load header
  26 - Check that signature verification succeeds
  27 - Corrupt the FIT image
  28 - Check that signature verification fails
  29 - Launch an FIT image without a pre-load header
  30 - Check that image verification fails
  31
  32 Tests run with both SHA1 and SHA256 hashing.
  33 """
  34
  35 import os
  36 import shutil
  37 import struct
  38 import pytest
  39 import u_boot_utils as util
  40 import vboot_forge
  41 import vboot_evil
  42
  43 # Only run the full suite on a few combinations, since it doesn't add any more
  44 # test coverage.
  45 TESTDATA_IN = [
  46     ['sha1-basic', 'sha1', '', None, False, True, False, False],
  47     ['sha1-pad', 'sha1', '', '-E -p 0x10000', False, False, False, False],
  48     ['sha1-pss', 'sha1', '-pss', None, False, False, False, False],
  49     ['sha1-pss-pad', 'sha1', '-pss', '-E -p 0x10000', False, False, False, False],
  50     ['sha256-basic', 'sha256', '', None, False, False, False, False],
  51     ['sha256-pad', 'sha256', '', '-E -p 0x10000', False, False, False, False],
  52     ['sha256-pss', 'sha256', '-pss', None, False, False, False, False],
  53     ['sha256-pss-pad', 'sha256', '-pss', '-E -p 0x10000', False, False, False, False],
  54     ['sha256-pss-required', 'sha256', '-pss', None, True, False, False, False],
  55     ['sha256-pss-pad-required', 'sha256', '-pss', '-E -p 0x10000', True, True, False, False],
  56     ['sha384-basic', 'sha384', '', None, False, False, False, False],
  57     ['sha384-pad', 'sha384', '', '-E -p 0x10000', False, False, False, False],
  58     ['algo-arg', 'algo-arg', '', '-o sha256,rsa2048', False, False, True, False],
  59     ['sha256-global-sign', 'sha256', '', '', False, False, False, True],
  60     ['sha256-global-sign-pss', 'sha256', '-pss', '', False, False, False, True],
  61 ]
  62
  63 # Mark all but the first test as slow, so they are not run with '-k not slow'
  64 TESTDATA = [TESTDATA_IN[0]]
  65 TESTDATA += [pytest.param(*v, marks=pytest.mark.slow) for v in TESTDATA_IN[1:]]
  66
  67 @pytest.mark.boardspec('sandbox')
  68 @pytest.mark.buildconfigspec('fit_signature')
  69 @pytest.mark.requiredtool('dtc')
  70 @pytest.mark.requiredtool('fdtget')
  71 @pytest.mark.requiredtool('fdtput')
  72 @pytest.mark.requiredtool('openssl')
  73 @pytest.mark.parametrize("name,sha_algo,padding,sign_options,required,full_test,algo_arg,global_sign",
  74                          TESTDATA)
  75 def test_vboot(u_boot_console, name, sha_algo, padding, sign_options, required,
  76                full_test, algo_arg, global_sign):
  77     """Test verified boot signing with mkimage and verification with 'bootm'.
  78
  79     This works using sandbox only as it needs to update the device tree used
  80     by U-Boot to hold public keys from the signing process.
  81
  82     The SHA1 and SHA256 tests are combined into a single test since the
  83     key-generation process is quite slow and we want to avoid doing it twice.
  84     """
  85     def dtc(dts):
  86         """Run the device tree compiler to compile a .dts file
  87
  88         The output file will be the same as the input file but with a .dtb
  89         extension.
  90
  91         Args:
  92             dts: Device tree file to compile.
  93         """
  94         dtb = dts.replace('.dts', '.dtb')
  95         util.run_and_log(cons, 'dtc %s %s%s -O dtb '
  96                          '-o %s%s' % (dtc_args, datadir, dts, tmpdir, dtb))
  97
  98     def dtc_options(dts, options):
  99         """Run the device tree compiler to compile a .dts file
 100
 101         The output file will be the same as the input file but with a .dtb
 102         extension.
 103
 104         Args:
 105             dts: Device tree file to compile.
 106             options: Options provided to the compiler.
 107         """
 108         dtb = dts.replace('.dts', '.dtb')
 109         util.run_and_log(cons, 'dtc %s %s%s -O dtb '
 110                          '-o %s%s %s' % (dtc_args, datadir, dts, tmpdir, dtb, options))
 111
 112     def run_binman(dtb):
 113         """Run binman to build an image
 114
 115         Args:
 116             dtb: Device tree file used as input file.
 117         """
 118         pythonpath = os.environ.get('PYTHONPATH', '')
 119         os.environ['PYTHONPATH'] = pythonpath + ':' + '%s/../scripts/dtc/pylibfdt' % tmpdir
 120         util.run_and_log(cons, [binman, 'build', '-d', "%s/%s" % (tmpdir,dtb),
 121                                 '-a', "pre-load-key-path=%s" % tmpdir, '-O',
 122                                 tmpdir, '-I', tmpdir])
 123         os.environ['PYTHONPATH'] = pythonpath
 124
 125     def run_bootm(sha_algo, test_type, expect_string, boots, fit=None):
 126         """Run a 'bootm' command U-Boot.
 127
 128         This always starts a fresh U-Boot instance since the device tree may
 129         contain a new public key.
 130
 131         Args:
 132             test_type: A string identifying the test type.
 133             expect_string: A string which is expected in the output.
 134             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to
 135                     use.
 136             boots: A boolean that is True if Linux should boot and False if
 137                     we are expected to not boot
 138             fit: FIT filename to load and verify
 139         """
 140         if not fit:
 141             fit = '%stest.fit' % tmpdir
 142         cons.restart_uboot()
 143         with cons.log.section('Verified boot %s %s' % (sha_algo, test_type)):
 144             output = cons.run_command_list(
 145                 ['host load hostfs - 100 %s' % fit,
 146                  'fdt addr 100',
 147                  'bootm 100'])
 148         assert expect_string in ''.join(output)
 149         if boots:
 150             assert 'sandbox: continuing, as we cannot run' in ''.join(output)
 151         else:
 152             assert('sandbox: continuing, as we cannot run'
 153                    not in ''.join(output))
 154
 155     def make_fit(its):
 156         """Make a new FIT from the .its source file.
 157
 158         This runs 'mkimage -f' to create a new FIT.
 159
 160         Args:
 161             its: Filename containing .its source.
 162         """
 163         util.run_and_log(cons, [mkimage, '-D', dtc_args, '-f',
 164                                 '%s%s' % (datadir, its), fit])
 165
 166     def sign_fit(sha_algo, options):
 167         """Sign the FIT
 168
 169         Signs the FIT and writes the signature into it. It also writes the
 170         public key into the dtb.
 171
 172         Args:
 173             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to
 174                     use.
 175             options: Options to provide to mkimage.
 176         """
 177         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
 178         if options:
 179             args += options.split(' ')
 180         cons.log.action('%s: Sign images' % sha_algo)
 181         util.run_and_log(cons, args)
 182
 183     def sign_fit_dtb(sha_algo, options, dtb):
 184         """Sign the FIT
 185
 186         Signs the FIT and writes the signature into it. It also writes the
 187         public key into the dtb.
 188
 189         Args:
 190             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to
 191                     use.
 192             options: Options to provide to mkimage.
 193         """
 194         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
 195         if options:
 196             args += options.split(' ')
 197         cons.log.action('%s: Sign images' % sha_algo)
 198         util.run_and_log(cons, args)
 199
 200     def sign_fit_norequire(sha_algo, options):
 201         """Sign the FIT
 202
 203         Signs the FIT and writes the signature into it. It also writes the
 204         public key into the dtb. It does not mark key as 'required' in dtb.
 205
 206         Args:
 207             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to
 208                     use.
 209             options: Options to provide to mkimage.
 210         """
 211         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, fit]
 212         if options:
 213             args += options.split(' ')
 214         cons.log.action('%s: Sign images' % sha_algo)
 215         util.run_and_log(cons, args)
 216
 217     def replace_fit_totalsize(size):
 218         """Replace FIT header's totalsize with something greater.
 219
 220         The totalsize must be less than or equal to FIT_SIGNATURE_MAX_SIZE.
 221         If the size is greater, the signature verification should return false.
 222
 223         Args:
 224             size: The new totalsize of the header
 225
 226         Returns:
 227             prev_size: The previous totalsize read from the header
 228         """
 229         total_size = 0
 230         with open(fit, 'r+b') as handle:
 231             handle.seek(4)
 232             total_size = handle.read(4)
 233             handle.seek(4)
 234             handle.write(struct.pack(">I", size))
 235         return struct.unpack(">I", total_size)[0]
 236
 237     def corrupt_file(fit, offset, value):
 238         """Corrupt a file
 239
 240         To corrupt a file, a value is written at the specified offset
 241
 242         Args:
 243             fit: The file to corrupt
 244             offset: Offset to write
 245             value: Value written
 246         """
 247         with open(fit, 'r+b') as handle:
 248             handle.seek(offset)
 249             handle.write(struct.pack(">I", value))
 250
 251     def create_rsa_pair(name):
 252         """Generate a new RSA key paid and certificate
 253
 254         Args:
 255             name: Name of of the key (e.g. 'dev')
 256         """
 257         public_exponent = 65537
 258
 259         if sha_algo == "sha384":
 260             rsa_keygen_bits = 3072
 261         else:
 262             rsa_keygen_bits = 2048
 263
 264         util.run_and_log(cons, 'openssl genpkey -algorithm RSA -out %s%s.key '
 265                      '-pkeyopt rsa_keygen_bits:%d '
 266                      '-pkeyopt rsa_keygen_pubexp:%d' %
 267                      (tmpdir, name, rsa_keygen_bits, public_exponent))
 268
 269         # Create a certificate containing the public key
 270         util.run_and_log(cons, 'openssl req -batch -new -x509 -key %s%s.key '
 271                          '-out %s%s.crt' % (tmpdir, name, tmpdir, name))
 272
 273     def test_with_algo(sha_algo, padding, sign_options):
 274         """Test verified boot with the given hash algorithm.
 275
 276         This is the main part of the test code. The same procedure is followed
 277         for both hashing algorithms.
 278
 279         Args:
 280             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to
 281                     use.
 282             padding: Either '' or '-pss', to select the padding to use for the
 283                     rsa signature algorithm.
 284             sign_options: Options to mkimage when signing a fit image.
 285         """
 286         # Compile our device tree files for kernel and U-Boot. These are
 287         # regenerated here since mkimage will modify them (by adding a
 288         # public key) below.
 289         dtc('sandbox-kernel.dts')
 290         dtc('sandbox-u-boot.dts')
 291
 292         # Build the FIT, but don't sign anything yet
 293         cons.log.action('%s: Test FIT with signed images' % sha_algo)
 294         make_fit('sign-images-%s%s.its' % (sha_algo, padding))
 295         run_bootm(sha_algo, 'unsigned images', ' - OK' if algo_arg else 'dev-', True)
 296
 297         # Sign images with our dev keys
 298         sign_fit(sha_algo, sign_options)
 299         run_bootm(sha_algo, 'signed images', 'dev+', True)
 300
 301         # Create a fresh .dtb without the public keys
 302         dtc('sandbox-u-boot.dts')
 303
 304         cons.log.action('%s: Test FIT with signed configuration' % sha_algo)
 305         make_fit('sign-configs-%s%s.its' % (sha_algo, padding))
 306         run_bootm(sha_algo, 'unsigned config', '%s+ OK' % ('sha256' if algo_arg else sha_algo), True)
 307
 308         # Sign images with our dev keys
 309         sign_fit(sha_algo, sign_options)
 310         run_bootm(sha_algo, 'signed config', 'dev+', True)
 311
 312         cons.log.action('%s: Check signed config on the host' % sha_algo)
 313
 314         util.run_and_log(cons, [fit_check_sign, '-f', fit, '-k', dtb])
 315
 316         if full_test:
 317             # Make sure that U-Boot checks that the config is in the list of
 318             # hashed nodes. If it isn't, a security bypass is possible.
 319             ffit = '%stest.forged.fit' % tmpdir
 320             shutil.copyfile(fit, ffit)
 321             with open(ffit, 'rb') as fd:
 322                 root, strblock = vboot_forge.read_fdt(fd)
 323             root, strblock = vboot_forge.manipulate(root, strblock)
 324             with open(ffit, 'w+b') as fd:
 325                 vboot_forge.write_fdt(root, strblock, fd)
 326             util.run_and_log_expect_exception(
 327                 cons, [fit_check_sign, '-f', ffit, '-k', dtb],
 328                 1, 'Failed to verify required signature')
 329
 330             run_bootm(sha_algo, 'forged config', 'Bad Data Hash', False, ffit)
 331
 332             # Try adding an evil root node. This should be detected.
 333             efit = '%stest.evilf.fit' % tmpdir
 334             shutil.copyfile(fit, efit)
 335             vboot_evil.add_evil_node(fit, efit, evil_kernel, 'fakeroot')
 336
 337             util.run_and_log_expect_exception(
 338                 cons, [fit_check_sign, '-f', efit, '-k', dtb],
 339                 1, 'Failed to verify required signature')
 340             run_bootm(sha_algo, 'evil fakeroot', 'Bad FIT kernel image format',
 341                       False, efit)
 342
 343             # Try adding an @ to the kernel node name. This should be detected.
 344             efit = '%stest.evilk.fit' % tmpdir
 345             shutil.copyfile(fit, efit)
 346             vboot_evil.add_evil_node(fit, efit, evil_kernel, 'kernel@')
 347
 348             msg = 'Signature checking prevents use of unit addresses (@) in nodes'
 349             util.run_and_log_expect_exception(
 350                 cons, [fit_check_sign, '-f', efit, '-k', dtb],
 351                 1, msg)
 352             run_bootm(sha_algo, 'evil kernel@', msg, False, efit)
 353
 354         # Create a new properly signed fit and replace header bytes
 355         make_fit('sign-configs-%s%s.its' % (sha_algo, padding))
 356         sign_fit(sha_algo, sign_options)
 357         bcfg = u_boot_console.config.buildconfig
 358         max_size = int(bcfg.get('config_fit_signature_max_size', 0x10000000), 0)
 359         existing_size = replace_fit_totalsize(max_size + 1)
 360         run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
 361                   False)
 362         cons.log.action('%s: Check overflowed FIT header totalsize' % sha_algo)
 363
 364         # Replace with existing header bytes
 365         replace_fit_totalsize(existing_size)
 366         run_bootm(sha_algo, 'signed config', 'dev+', True)
 367         cons.log.action('%s: Check default FIT header totalsize' % sha_algo)
 368
 369         # Increment the first byte of the signature, which should cause failure
 370         sig = util.run_and_log(cons, 'fdtget -t bx %s %s value' %
 371                                (fit, sig_node))
 372         byte_list = sig.split()
 373         byte = int(byte_list[0], 16)
 374         byte_list[0] = '%x' % (byte + 1)
 375         sig = ' '.join(byte_list)
 376         util.run_and_log(cons, 'fdtput -t bx %s %s value %s' %
 377                          (fit, sig_node, sig))
 378
 379         run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
 380                   False)
 381
 382         cons.log.action('%s: Check bad config on the host' % sha_algo)
 383         util.run_and_log_expect_exception(
 384             cons, [fit_check_sign, '-f', fit, '-k', dtb],
 385             1, 'Failed to verify required signature')
 386
 387     def test_required_key(sha_algo, padding, sign_options):
 388         """Test verified boot with the given hash algorithm.
 389
 390         This function tests if U-Boot rejects an image when a required key isn't
 391         used to sign a FIT.
 392
 393         Args:
 394             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to use
 395             padding: Either '' or '-pss', to select the padding to use for the
 396                     rsa signature algorithm.
 397             sign_options: Options to mkimage when signing a fit image.
 398         """
 399         # Compile our device tree files for kernel and U-Boot. These are
 400         # regenerated here since mkimage will modify them (by adding a
 401         # public key) below.
 402         dtc('sandbox-kernel.dts')
 403         dtc('sandbox-u-boot.dts')
 404
 405         cons.log.action('%s: Test FIT with configs images' % sha_algo)
 406
 407         # Build the FIT with prod key (keys required) and sign it. This puts the
 408         # signature into sandbox-u-boot.dtb, marked 'required'
 409         make_fit('sign-configs-%s%s-prod.its' % (sha_algo, padding))
 410         sign_fit(sha_algo, sign_options)
 411
 412         # Build the FIT with dev key (keys NOT required). This adds the
 413         # signature into sandbox-u-boot.dtb, NOT marked 'required'.
 414         make_fit('sign-configs-%s%s.its' % (sha_algo, padding))
 415         sign_fit_norequire(sha_algo, sign_options)
 416
 417         # So now sandbox-u-boot.dtb two signatures, for the prod and dev keys.
 418         # Only the prod key is set as 'required'. But FIT we just built has
 419         # a dev signature only (sign_fit_norequire() overwrites the FIT).
 420         # Try to boot the FIT with dev key. This FIT should not be accepted by
 421         # U-Boot because the prod key is required.
 422         run_bootm(sha_algo, 'required key', '', False)
 423
 424         # Build the FIT with dev key (keys required) and sign it. This puts the
 425         # signature into sandbox-u-boot.dtb, marked 'required'.
 426         make_fit('sign-configs-%s%s.its' % (sha_algo, padding))
 427         sign_fit(sha_algo, sign_options)
 428
 429         # Set the required-mode policy to "any".
 430         # So now sandbox-u-boot.dtb two signatures, for the prod and dev keys.
 431         # Both the dev and prod key are set as 'required'. But FIT we just built has
 432         # a dev signature only (sign_fit() overwrites the FIT).
 433         # Try to boot the FIT with dev key. This FIT should be accepted by
 434         # U-Boot because the dev key is required and policy is "any" required key.
 435         util.run_and_log(cons, 'fdtput -t s %s /signature required-mode any' %
 436                          (dtb))
 437         run_bootm(sha_algo, 'multi required key', 'dev+', True)
 438
 439         # Set the required-mode policy to "all".
 440         # So now sandbox-u-boot.dtb two signatures, for the prod and dev keys.
 441         # Both the dev and prod key are set as 'required'. But FIT we just built has
 442         # a dev signature only (sign_fit() overwrites the FIT).
 443         # Try to boot the FIT with dev key. This FIT should not be accepted by
 444         # U-Boot because the prod key is required and policy is "all" required key
 445         util.run_and_log(cons, 'fdtput -t s %s /signature required-mode all' %
 446                          (dtb))
 447         run_bootm(sha_algo, 'multi required key', '', False)
 448
 449     def test_global_sign(sha_algo, padding, sign_options):
 450         """Test global image signature with the given hash algorithm and padding.
 451
 452         Args:
 453             sha_algo: Either 'sha1' or 'sha256', to select the algorithm to use
 454             padding: Either '' or '-pss', to select the padding to use for the
 455                     rsa signature algorithm.
 456         """
 457
 458         dtb = '%ssandbox-u-boot-global%s.dtb' % (tmpdir, padding)
 459         cons.config.dtb = dtb
 460
 461         # Compile our device tree files for kernel and U-Boot. These are
 462         # regenerated here since mkimage will modify them (by adding a
 463         # public key) below.
 464         dtc('sandbox-kernel.dts')
 465         dtc_options('sandbox-u-boot-global%s.dts' % padding, '-p 1024')
 466
 467         # Build the FIT with dev key (keys NOT required). This adds the
 468         # signature into sandbox-u-boot.dtb, NOT marked 'required'.
 469         make_fit('simple-images.its')
 470         sign_fit_dtb(sha_algo, '', dtb)
 471
 472         # Build the dtb for binman that define the pre-load header
 473         # with the global sigature.
 474         dtc('sandbox-binman%s.dts' % padding)
 475
 476         # Run binman to create the final image with the not signed fit
 477         # and the pre-load header that contains the global signature.
 478         run_binman('sandbox-binman%s.dtb' % padding)
 479
 480         # Check that the signature is correctly verified by u-boot
 481         run_bootm(sha_algo, 'global image signature',
 482                   'signature check has succeed', True, "%ssandbox.img" % tmpdir)
 483
 484         # Corrupt the image (just one byte after the pre-load header)
 485         corrupt_file("%ssandbox.img" % tmpdir, 4096, 255);
 486
 487         # Check that the signature verification fails
 488         run_bootm(sha_algo, 'global image signature',
 489                   'signature check has failed', False, "%ssandbox.img" % tmpdir)
 490
 491         # Check that the boot fails if the global signature is not provided
 492         run_bootm(sha_algo, 'global image signature', 'signature is mandatory', False)
 493
 494     cons = u_boot_console
 495     tmpdir = os.path.join(cons.config.result_dir, name) + '/'
 496     if not os.path.exists(tmpdir):
 497         os.mkdir(tmpdir)
 498     datadir = cons.config.source_dir + '/test/py/tests/vboot/'
 499     fit = '%stest.fit' % tmpdir
 500     mkimage = cons.config.build_dir + '/tools/mkimage'
 501     binman = cons.config.source_dir + '/tools/binman/binman'
 502     fit_check_sign = cons.config.build_dir + '/tools/fit_check_sign'
 503     dtc_args = '-I dts -O dtb -i %s' % tmpdir
 504     dtb = '%ssandbox-u-boot.dtb' % tmpdir
 505     sig_node = '/configurations/conf-1/signature'
 506
 507     create_rsa_pair('dev')
 508     create_rsa_pair('prod')
 509
 510     # Create a number kernel image with zeroes
 511     with open('%stest-kernel.bin' % tmpdir, 'wb') as fd:
 512         fd.write(500 * b'\0')
 513
 514     # Create a second kernel image with ones
 515     evil_kernel = '%stest-kernel1.bin' % tmpdir
 516     with open(evil_kernel, 'wb') as fd:
 517         fd.write(500 * b'\x01')
 518
 519     try:
 520         # We need to use our own device tree file. Remember to restore it
 521         # afterwards.
 522         old_dtb = cons.config.dtb
 523         cons.config.dtb = dtb
 524         if global_sign:
 525             test_global_sign(sha_algo, padding, sign_options)
 526         elif required:
 527             test_required_key(sha_algo, padding, sign_options)
 528         else:
 529             test_with_algo(sha_algo, padding, sign_options)
 530     finally:
 531         # Go back to the original U-Boot with the correct dtb.
 532         cons.config.dtb = old_dtb
 533         cons.restart_uboot()