Quelle  payload_signer.py

#!/usr/bin/env python3
#
# Copyright (C) 2022 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import common
import logging
import shlex
import argparse
import tempfile
import zipfile
import shutil
from common import OPTIONS, OptionHandler
from ota_signing_utils import AddSigningArgumentParse

logger = logging.getLogger(__name__)

OPTIONS.payload_signer = None
OPTIONS.payload_signer_args = []
OPTIONS.payload_signer_maximum_signature_size = None
OPTIONS.package_key = None

PAYLOAD_BIN = 'payload.bin'
PAYLOAD_PROPERTIES_TXT = 'payload_properties.txt'

class SignerOptions(OptionHandler):

  @staticmethod
  def ParseOptions(o, a):
    if o in ("-k", "--package_key"):
      OPTIONS.package_key = a
    elif o == "--payload_signer":
      OPTIONS.payload_signer = a
    elif o == "--payload_signer_args":
      OPTIONS.payload_signer_args = shlex.split(a)
    elif o == "--payload_signer_maximum_signature_size":
      OPTIONS.payload_signer_maximum_signature_size = a
    elif o == "--payload_signer_key_size":
      # TODO(xunchang) remove this option after cleaning up the callers.
      logger.warning("The option '--payload_signer_key_size' is deprecated."
                      " Use '--payload_signer_maximum_signature_size' instead.")
      OPTIONS.payload_signer_maximum_signature_size = a
    else:
      return False
    return True

  def __init__(self):
    super().__init__(
      ["payload_signer=",
       "package_key=",
       "payload_signer_args=",
       "payload_signer_maximum_signature_size=",
       "payload_signer_key_size="],
       SignerOptions.ParseOptions
    )


signer_options = SignerOptions()


class PayloadSigner(object):
  """A class that wraps the payload signing works.

  When generating a Payload, hashes of the payload and metadata files will be
  signed with the device key, either by calling an external payload signer or
  by calling openssl with the package key. This class provides a unified
  interface, so that callers can just call PayloadSigner.Sign().

  If an external payload signer has been specified (OPTIONS.payload_signer), it
  calls the signer with the provided args (OPTIONS.payload_signer_args). Note
  that the signing key should be provided as part of the payload_signer_args.
  Otherwise without an external signer, it uses the package key
  (OPTIONS.package_key) and calls openssl for the signing works.
  """

  def __init__(self, package_key=None, private_key_suffix=None, pw=None, payload_signer=None,
               payload_signer_args=None, payload_signer_maximum_signature_size=None):
    if package_key is None:
      package_key = OPTIONS.package_key
    if private_key_suffix is None:
      private_key_suffix = OPTIONS.private_key_suffix
    if payload_signer_args is None:
      payload_signer_args = OPTIONS.payload_signer_args
    if payload_signer_maximum_signature_size is None:
      payload_signer_maximum_signature_size = OPTIONS.payload_signer_maximum_signature_size

    if payload_signer is None:
      # Prepare the payload signing key.
      private_key = package_key + private_key_suffix

      cmd = ["openssl", "pkcs8", "-in", private_key, "-inform", "DER"]
      cmd.extend(["-passin", "pass:" + pw] if pw else ["-nocrypt"])
      signing_key = common.MakeTempFile(prefix="key-", suffix=".key")
      cmd.extend(["-out", signing_key])
      common.RunAndCheckOutput(cmd, verbose=True)

      self.signer = "openssl"
      self.signer_args = ["pkeyutl", "-sign", "-inkey", signing_key,
                          "-pkeyopt", "digest:sha256"]
      self.maximum_signature_size = self._GetMaximumSignatureSizeInBytes(
          signing_key)
    else:
      self.signer = payload_signer
      self.signer_args = payload_signer_args
      if payload_signer_maximum_signature_size:
        self.maximum_signature_size = int(
            payload_signer_maximum_signature_size)
      else:
        # The legacy config uses RSA2048 keys.
        logger.warning("The maximum signature size for payload signer is not"
                       " set, default to 256 bytes.")
        self.maximum_signature_size = 256

  @staticmethod
  def _GetMaximumSignatureSizeInBytes(signing_key):
    out_signature_size_file = common.MakeTempFile("signature_size")
    cmd = ["delta_generator", "--out_maximum_signature_size_file={}".format(
        out_signature_size_file), "--private_key={}".format(signing_key)]
    common.RunAndCheckOutput(cmd, verbose=True)
    with open(out_signature_size_file) as f:
      signature_size = f.read().rstrip()
    logger.info("%s outputs the maximum signature size: %s", cmd[0],
                signature_size)
    return int(signature_size)

  @staticmethod
  def _Run(cmd):
    common.RunAndCheckOutput(cmd, stdout=None, stderr=None)

  def SignPayload(self, unsigned_payload):

    # 1. Generate hashes of the payload and metadata files.
    payload_sig_file = common.MakeTempFile(prefix="sig-", suffix=".bin")
    metadata_sig_file = common.MakeTempFile(prefix="sig-", suffix=".bin")
    cmd = ["delta_generator",
           "--in_file=" + unsigned_payload,
           "--signature_size=" + str(self.maximum_signature_size),
           "--out_metadata_hash_file=" + metadata_sig_file,
           "--out_hash_file=" + payload_sig_file]
    self._Run(cmd)

    # 2. Sign the hashes.
    signed_payload_sig_file = self.SignHashFile(payload_sig_file)
    signed_metadata_sig_file = self.SignHashFile(metadata_sig_file)

    # 3. Insert the signatures back into the payload file.
    signed_payload_file = common.MakeTempFile(prefix="signed-payload-",
                                              suffix=".bin")
    cmd = ["delta_generator",
           "--in_file=" + unsigned_payload,
           "--out_file=" + signed_payload_file,
           "--signature_size=" + str(self.maximum_signature_size),
           "--metadata_signature_file=" + signed_metadata_sig_file,
           "--payload_signature_file=" + signed_payload_sig_file]
    self._Run(cmd)
    return signed_payload_file

  def SignHashFile(self, in_file):
    """Signs the given input file. Returns the output filename."""
    out_file = common.MakeTempFile(prefix="signed-", suffix=".bin")
    cmd = [self.signer] + self.signer_args + ['-in', in_file, '-out', out_file]
    common.RunAndCheckOutput(cmd)
    return out_file

def GeneratePayloadProperties(payload_file):
    properties_file = common.MakeTempFile(prefix="payload-properties-",
                                          suffix=".txt")
    cmd = ["delta_generator",
           "--in_file=" + payload_file,
           "--properties_file=" + properties_file]
    common.RunAndCheckOutput(cmd)
    return properties_file

def SignOtaPackage(input_path, output_path):
  payload_signer = PayloadSigner(
      OPTIONS.package_key, OPTIONS.private_key_suffix,
      None, OPTIONS.payload_signer, OPTIONS.payload_signer_args)
  common.ZipExclude(input_path, output_path, [PAYLOAD_BIN, PAYLOAD_PROPERTIES_TXT])
  with tempfile.NamedTemporaryFile() as unsigned_payload, zipfile.ZipFile(input_path, "r", allowZip64=True) as zfp:
    with zfp.open("payload.bin") as payload_fp:
      shutil.copyfileobj(payload_fp, unsigned_payload)
      unsigned_payload.flush()
    signed_payload = payload_signer.SignPayload(unsigned_payload.name)
    properties_file = GeneratePayloadProperties(signed_payload)
    with zipfile.ZipFile(output_path, "a", compression=zipfile.ZIP_STORED, allowZip64=True) as output_zfp:
      common.ZipWrite(output_zfp, signed_payload, PAYLOAD_BIN)
      common.ZipWrite(output_zfp, properties_file, PAYLOAD_PROPERTIES_TXT)


def main(argv):
  parser = argparse.ArgumentParser(
      prog=argv[0], description="Given a series of .img files, produces a full OTA package that installs thoese images")
  parser.add_argument("input_ota", type=str,
                      help="Input OTA for signing")
  parser.add_argument('output_ota', type=str,
                      help='Output OTA for the signed package')
  parser.add_argument("-v", action="store_true",
                      help="Enable verbose logging", dest="verbose")
  AddSigningArgumentParse(parser)
  args = parser.parse_args(argv[1:])
  input_ota = args.input_ota
  output_ota = args.output_ota
  if args.verbose:
    OPTIONS.verbose = True
  common.InitLogging()
  if args.package_key:
    OPTIONS.package_key = args.package_key
  logger.info("Re-signing OTA package {}".format(input_ota))
  SignOtaPackage(input_ota, output_ota)

if __name__ == "__main__":
  import sys
  main(sys.argv)