Example #1
0
 def __init__(self, data, imageinfo=None, mbn_properties=None,
              general_properties=None,
              encdec=None,
              debug_dir=None,
              debug_prefix=None,
              debug_suffix=None,):
     SecParseGenBase.__init__(self, data, imageinfo, general_properties,
                              encdec, debug_dir, debug_prefix, debug_suffix)
     
     # Check the arguments
     if imageinfo is not None:
         mbn_properties = imageinfo.image_type.mbn_properties
     if mbn_properties is None:
         raise RuntimeError('MBN properties must not be None.')
     
     # Initialize the mbn parsegen
     self._mbn_parsegen = mbn.ParseGenMbn(data, 
                                          mbn_properties.header_size,
                                          mbn_properties.preamble_size,
                                          mbn_properties.has_magic_num, 
                                          mbn_properties.page_size, 
                                          mbn_properties.num_of_pages,
                                          mbn_properties.ota_enabled, 
                                          mbn_properties.min_size_with_pad,
                                          self.debug_dir, 
                                          self.debug_prefix,
                                          self.debug_suffix)
     
     # Set the security attributes from the mbn parser
     self.data_signature = self._mbn_parsegen.sign
     self.cert_chain = self._mbn_parsegen.cert_chain
     self.encryption_params = self._mbn_parsegen.encryption_params
Example #2
0
    def __init__(self,
                 data,
                 imageinfo=None,
                 mbn_properties=None,
                 general_properties=None,
                 encdec=None,
                 debug_dir=None,
                 debug_prefix=None,
                 debug_suffix=None,
                 validating=False,
                 signing=False,
                 parsegens=None,
                 sign_attr=False):
        SecParseGenBase.__init__(self, data, imageinfo, general_properties,
                                 encdec, debug_dir, debug_prefix, debug_suffix,
                                 validating, signing, parsegens, sign_attr)

        # Check the arguments
        if imageinfo is not None:
            mbn_properties = imageinfo.image_type.mbn_properties
        if mbn_properties is None:
            raise RuntimeError('MBN properties must not be None.')

        # Set padding based on authorities
        if self.qti_signing_enabled and self.oem_signing_enabled:
            pad_max_sig_size, pad_max_cc_size = MAX_SIG_SIZE, self.get_cert_chain_size(
                defines.AUTHORITY_OEM)
        else:
            pad_max_sig_size, pad_max_cc_size = 0, 0
        pad_max_ep_size = len(self.encdec.get_encryption_parameters_blob()
                              ) if self.encdec is not None else 0

        # Initialize the mbn parsegen
        self._mbn_parsegen = mbn.ParseGenMbn(
            data, mbn_properties.header_size,
            SECBOOT_MBN_HDR[self.secboot_version], self.debug_dir,
            self.debug_prefix, self.debug_suffix, pad_max_sig_size,
            pad_max_cc_size, pad_max_ep_size)

        self.code_size = self._mbn_parsegen.code_size

        # Sig or cert chain should not exist when corresponding authority permissions are disabled
        self.validate_image_sig()

        # Private variables
        self._data_signature_qti = ''
        self._cert_chain_qti = ''

        # Extract encryption params
        self.encryption_params = self._mbn_parsegen.encryption_params

        # Backup authority
        authority = self.authority

        # Set the QTI signature/QTI cert chain if QTI signing is enabled
        # Needs to be done before getting OEM data
        self.authority = defines.AUTHORITY_QTI
        self.data_signature = self._mbn_parsegen.sign_qti
        self.cert_chain = self._mbn_parsegen.cert_chain_qti

        # Set the OEM signature/OEM cert chain
        self.authority = defines.AUTHORITY_OEM
        self.data_signature = self._mbn_parsegen.sign
        self.cert_chain = self._mbn_parsegen.cert_chain

        # Restore authority
        self.authority = authority

        # If incoming image is signed or encrypted, validate the header version
        if self.is_signed() or self.is_encrypted():
            self._mbn_parsegen.header.validate()