diff options
Diffstat (limited to 'scripts/paycheck.py')
| -rwxr-xr-x | scripts/paycheck.py | 232 |
1 files changed, 232 insertions, 0 deletions
diff --git a/scripts/paycheck.py b/scripts/paycheck.py new file mode 100755 index 00000000..0195f531 --- /dev/null +++ b/scripts/paycheck.py @@ -0,0 +1,232 @@ +#!/usr/bin/python2 +# +# Copyright (c) 2013 The Chromium OS Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +"""Command-line tool for checking and applying Chrome OS update payloads.""" + +from __future__ import print_function + +import optparse +import os +import sys + +# pylint: disable=F0401 +lib_dir = os.path.join(os.path.dirname(__file__), 'lib') +if os.path.exists(lib_dir) and os.path.isdir(lib_dir): + sys.path.insert(1, lib_dir) +import update_payload + + +_TYPE_FULL = 'full' +_TYPE_DELTA = 'delta' + + +def ParseArguments(argv): + """Parse and validate command-line arguments. + + Args: + argv: command-line arguments to parse (excluding the program name) + + Returns: + A tuple (opts, payload, extra_args), where `opts' are the options + returned by the parser, `payload' is the name of the payload file + (mandatory argument) and `extra_args' are any additional command-line + arguments. + """ + parser = optparse.OptionParser( + usage=('Usage: %prog [OPTION...] PAYLOAD [DST_KERN DST_ROOT ' + '[SRC_KERN SRC_ROOT]]'), + description=('Applies a Chrome OS update PAYLOAD to SRC_KERN and ' + 'SRC_ROOT emitting DST_KERN and DST_ROOT, respectively. ' + 'SRC_KERN and SRC_ROOT are only needed for delta payloads. ' + 'When no partitions are provided, verifies the payload ' + 'integrity.'), + epilog=('Note: a payload may verify correctly but fail to apply, and ' + 'vice versa; this is by design and can be thought of as static ' + 'vs dynamic correctness. A payload that both verifies and ' + 'applies correctly should be safe for use by the Chrome OS ' + 'Update Engine. Use --check to verify a payload prior to ' + 'applying it.')) + + check_opts = optparse.OptionGroup(parser, 'Checking payload integrity') + check_opts.add_option('-c', '--check', action='store_true', default=False, + help=('force payload integrity check (e.g. before ' + 'applying)')) + check_opts.add_option('-D', '--describe', action='store_true', default=False, + help='Print a friendly description of the payload.') + check_opts.add_option('-r', '--report', metavar='FILE', + help="dump payload report (`-' for stdout)") + check_opts.add_option('-t', '--type', metavar='TYPE', dest='assert_type', + help=("assert that payload is either `%s' or `%s'" % + (_TYPE_FULL, _TYPE_DELTA))) + check_opts.add_option('-z', '--block-size', metavar='NUM', default=0, + type='int', + help='assert a non-default (4096) payload block size') + check_opts.add_option('-u', '--allow-unhashed', action='store_true', + default=False, help='allow unhashed operations') + check_opts.add_option('-d', '--disabled_tests', metavar='TESTLIST', + default=(), + help=('comma-separated list of tests to disable; ' + 'available values: ' + + ', '.join(update_payload.CHECKS_TO_DISABLE))) + check_opts.add_option('-k', '--key', metavar='FILE', + help=('Override standard key used for signature ' + 'validation')) + check_opts.add_option('-m', '--meta-sig', metavar='FILE', + help='verify metadata against its signature') + check_opts.add_option('-p', '--root-part-size', metavar='NUM', + default=0, type='int', + help=('override rootfs partition size auto-inference')) + check_opts.add_option('-P', '--kern-part-size', metavar='NUM', + default=0, type='int', + help=('override kernel partition size auto-inference')) + parser.add_option_group(check_opts) + + trace_opts = optparse.OptionGroup(parser, 'Applying payload') + trace_opts.add_option('-x', '--extract-bsdiff', action='store_true', + default=False, + help=('use temp input/output files with BSDIFF ' + 'operations (not in-place)')) + trace_opts.add_option('--bspatch-path', metavar='FILE', + help=('use the specified bspatch binary')) + parser.add_option_group(trace_opts) + + trace_opts = optparse.OptionGroup(parser, 'Block tracing') + trace_opts.add_option('-b', '--root-block', metavar='BLOCK', type='int', + help='trace the origin for a rootfs block') + trace_opts.add_option('-B', '--kern-block', metavar='BLOCK', type='int', + help='trace the origin for a kernel block') + trace_opts.add_option('-s', '--skip', metavar='NUM', default='0', type='int', + help='skip first NUM occurrences of traced block') + parser.add_option_group(trace_opts) + + # Parse command-line arguments. + opts, args = parser.parse_args(argv) + + # Validate a value given to --type, if any. + if opts.assert_type not in (None, _TYPE_FULL, _TYPE_DELTA): + parser.error('invalid argument to --type: %s' % opts.assert_type) + + # Convert and validate --disabled_tests value list, if provided. + if opts.disabled_tests: + opts.disabled_tests = opts.disabled_tests.split(',') + for test in opts.disabled_tests: + if test not in update_payload.CHECKS_TO_DISABLE: + parser.error('invalid argument to --disabled_tests: %s' % test) + + # Ensure consistent use of block tracing options. + do_block_trace = not (opts.root_block is None and opts.kern_block is None) + if opts.skip and not do_block_trace: + parser.error('--skip must be used with either --root-block or --kern-block') + + # There are several options that imply --check. + opts.check = (opts.check or opts.report or opts.assert_type or + opts.block_size or opts.allow_unhashed or + opts.disabled_tests or opts.meta_sig or opts.key or + opts.root_part_size or opts.kern_part_size) + + # Check number of arguments, enforce payload type accordingly. + if len(args) == 3: + if opts.assert_type == _TYPE_DELTA: + parser.error('%s payload requires source partition arguments' % + _TYPE_DELTA) + opts.assert_type = _TYPE_FULL + elif len(args) == 5: + if opts.assert_type == _TYPE_FULL: + parser.error('%s payload does not accept source partition arguments' % + _TYPE_FULL) + opts.assert_type = _TYPE_DELTA + elif len(args) == 1: + # Not applying payload; if block tracing not requested either, do an + # integrity check. + if not do_block_trace: + opts.check = True + if opts.extract_bsdiff: + parser.error('--extract-bsdiff can only be used when applying payloads') + if opts.bspatch_path: + parser.error('--bspatch-path can only be used when applying payloads') + else: + parser.error('unexpected number of arguments') + + # By default, look for a metadata-signature file with a name based on the name + # of the payload we are checking. We only do it if check was triggered. + if opts.check and not opts.meta_sig: + default_meta_sig = args[0] + '.metadata-signature' + if os.path.isfile(default_meta_sig): + opts.meta_sig = default_meta_sig + print('Using default metadata signature', opts.meta_sig, file=sys.stderr) + + return opts, args[0], args[1:] + + +def main(argv): + # Parse and validate arguments. + options, payload_file_name, extra_args = ParseArguments(argv[1:]) + + with open(payload_file_name) as payload_file: + payload = update_payload.Payload(payload_file) + try: + # Initialize payload. + payload.Init() + + if options.describe: + payload.Describe() + + # Perform payload integrity checks. + if options.check: + report_file = None + do_close_report_file = False + metadata_sig_file = None + try: + if options.report: + if options.report == '-': + report_file = sys.stdout + else: + report_file = open(options.report, 'w') + do_close_report_file = True + + metadata_sig_file = options.meta_sig and open(options.meta_sig) + payload.Check( + pubkey_file_name=options.key, + metadata_sig_file=metadata_sig_file, + report_out_file=report_file, + assert_type=options.assert_type, + block_size=int(options.block_size), + rootfs_part_size=options.root_part_size, + kernel_part_size=options.kern_part_size, + allow_unhashed=options.allow_unhashed, + disabled_tests=options.disabled_tests) + finally: + if metadata_sig_file: + metadata_sig_file.close() + if do_close_report_file: + report_file.close() + + # Trace blocks. + if options.root_block is not None: + payload.TraceBlock(options.root_block, options.skip, sys.stdout, False) + if options.kern_block is not None: + payload.TraceBlock(options.kern_block, options.skip, sys.stdout, True) + + # Apply payload. + if extra_args: + dargs = {'bsdiff_in_place': not options.extract_bsdiff} + if options.bspatch_path: + dargs['bspatch_path'] = options.bspatch_path + if options.assert_type == _TYPE_DELTA: + dargs['old_kernel_part'] = extra_args[2] + dargs['old_rootfs_part'] = extra_args[3] + + payload.Apply(extra_args[0], extra_args[1], **dargs) + + except update_payload.PayloadError, e: + sys.stderr.write('Error: %s\n' % e) + return 1 + + return 0 + + +if __name__ == '__main__': + sys.exit(main(sys.argv)) |