2019-12-03 07:45:02 +08:00
## @ GenCapsuleFirmware.py
#
2020-04-11 08:25:58 +08:00
# Copyright (c) 2017-2020, Intel Corporation. All rights reserved.<BR>
2019-12-03 07:45:02 +08:00
# SPDX-License-Identifier: BSD-2-Clause-Patent
#
##
import os
import argparse
import subprocess
import sys
import re
import struct
import uuid
2020-01-14 00:19:16 +08:00
import binascii
2019-12-03 07:45:02 +08:00
from ctypes import *
sys . dont_write_bytecode = True
from BuildUtility import rsa_sign_file , gen_pub_key
2019-12-09 07:17:32 +08:00
from CommonUtility import *
2019-12-03 07:45:02 +08:00
class FmpCapsuleImageHeaderClass ( object ) :
# typedef struct {
# UINT32 Version;
#
# ///
# /// Used to identify device firmware targeted by this update. This guid is matched by
# /// system firmware against ImageTypeId field within a EFI_FIRMWARE_IMAGE_DESCRIPTOR
# ///
# EFI_GUID UpdateImageTypeId;
#
# ///
# /// Passed as ImageIndex in call to EFI_FIRMWARE_MANAGEMENT_PROTOCOL.SetImage ()
# ///
# UINT8 UpdateImageIndex;
# UINT8 reserved_bytes[3];
#
# ///:
# /// Size of the binary update image which immediately follows this structure
# ///
# UINT32 UpdateImageSize;
#
# ///
# /// Size of the VendorCode bytes which optionally immediately follow binary update image in the capsule
# ///
# UINT32 UpdateVendorCodeSize;
#
# ///
# /// The HardwareInstance to target with this update. If value is zero it means match all
# /// HardwareInstances. This field allows update software to target only a single device in
# /// cases where there are more than one device with the same ImageTypeId GUID.
# /// This header is outside the signed data of the Authentication Info structure and
# /// therefore can be modified without changing the Auth data.
# ///
# UINT64 UpdateHardwareInstance;
# } EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER;
#
# #define EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION 0x00000002
_StructFormat = ' <I16sB3BIIQ '
_StructSize = struct . calcsize ( _StructFormat )
EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION = 0x00000002
def __init__ ( self ) :
self . _Valid = False
self . Version = self . EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION
self . UpdateImageTypeId = uuid . UUID (
' 00000000-0000-0000-0000-000000000000 ' )
self . UpdateImageIndex = 0
self . UpdateImageSize = 0
self . UpdateVendorCodeSize = 0
self . UpdateHardwareInstance = 0x0000000000000000
self . Payload = b ' '
self . VendorCodeBytes = b ' '
def Encode ( self ) :
self . UpdateImageSize = len ( self . Payload )
self . UpdateVendorCodeSize = len ( self . VendorCodeBytes )
FmpCapsuleImageHeader = struct . pack (
self . _StructFormat , self . Version , self . UpdateImageTypeId . bytes_le ,
self . UpdateImageIndex , 0 , 0 , 0 , self . UpdateImageSize ,
self . UpdateVendorCodeSize , self . UpdateHardwareInstance )
self . _Valid = True
2020-01-14 00:19:16 +08:00
return FmpCapsuleImageHeader + self . Payload + ( self . VendorCodeBytes ) . encode ( )
2019-12-03 07:45:02 +08:00
def Decode ( self , Buffer ) :
if len ( Buffer ) < self . _StructSize :
raise ValueError
( Version , UpdateImageTypeId , UpdateImageIndex , r0 , r1 , r2 ,
UpdateImageSize , UpdateVendorCodeSize ,
UpdateHardwareInstance ) = struct . unpack ( self . _StructFormat ,
Buffer [ 0 : self . _StructSize ] )
if Version < self . EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION :
raise ValueError
if UpdateImageIndex < 1 :
raise ValueError
if UpdateImageSize + UpdateVendorCodeSize != len ( Buffer [
self . _StructSize : ] ) :
raise ValueError
self . Version = Version
self . UpdateImageTypeId = uuid . UUID ( bytes_le = UpdateImageTypeId )
self . UpdateImageIndex = UpdateImageIndex
self . UpdateImageSize = UpdateImageSize
self . UpdateVendorCodeSize = UpdateVendorCodeSize
self . UpdateHardwareInstance = UpdateHardwareInstance
self . Payload = Buffer [ self . _StructSize : self . _StructSize +
UpdateImageSize ]
self . VendorCodeBytes = Buffer [ self . _StructSize + UpdateImageSize : ]
self . _Valid = True
return Buffer [ self . _StructSize : ]
def DumpInfo ( self , padding = ' ' ) :
if not self . _Valid :
raise ValueError
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.Version = {Version:08X} ' . format (
Version = self . Version ) )
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.UpdateImageTypeId = {UpdateImageTypeId} ' . format (
UpdateImageTypeId = str ( self . UpdateImageTypeId ) . upper ( ) ) )
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.UpdateImageIndex = {UpdateImageIndex:08X} ' . format (
UpdateImageIndex = self . UpdateImageIndex ) )
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.UpdateImageSize = {UpdateImageSize:08X} ' . format (
UpdateImageSize = self . UpdateImageSize ) )
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.UpdateVendorCodeSize = {UpdateVendorCodeSize:08X} ' . format (
UpdateVendorCodeSize = self . UpdateVendorCodeSize ) )
print (
padding +
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.UpdateHardwareInstance = {UpdateHardwareInstance:016X} ' . format (
UpdateHardwareInstance = self . UpdateHardwareInstance ) )
print (
padding +
' sizeof (Payload) = {Size:08X} ' . format (
Size = len ( self . Payload ) ) )
print (
padding +
' sizeof (VendorCodeBytes) = {Size:08X} ' . format (
Size = len ( self . VendorCodeBytes ) ) )
class FmpCapsuleHeaderClass ( object ) :
# typedef struct {
# UINT32 Version;
#
# ///
# /// The number of drivers included in the capsule and the number of corresponding
# /// offsets stored in ItemOffsetList array.
# ///
# UINT16 EmbeddedDriverCount;
#
# ///
# /// The number of payload items included in the capsule and the number of
# /// corresponding offsets stored in the ItemOffsetList array.
# ///
# UINT16 PayloadItemCount;
#
# ///
# /// Variable length array of dimension [EmbeddedDriverCount + PayloadItemCount]
# /// containing offsets of each of the drivers and payload items contained within the capsule
# ///
# // UINT64 ItemOffsetList[];
# } EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER;
#
# #define EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION 0x00000001
_StructFormat = ' <IHH '
_StructSize = struct . calcsize ( _StructFormat )
_ItemOffsetFormat = ' <Q '
_ItemOffsetSize = struct . calcsize ( _ItemOffsetFormat )
EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION = 0x00000001
def __init__ ( self ) :
self . _Valid = False
self . Version = self . EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION
self . EmbeddedDriverCount = 0
self . PayloadItemCount = 0
self . _ItemOffsetList = [ ]
self . _EmbeddedDriverList = [ ]
self . _PayloadList = [ ]
self . _FmpCapsuleImageHeaderList = [ ]
def AddEmbeddedDriver ( self , EmbeddedDriver ) :
self . _EmbeddedDriverList . append ( EmbeddedDriver )
def GetEmbeddedDriver ( self , Index ) :
if Index > len ( self . _EmbeddedDriverList ) :
raise ValueError
return self . _EmbeddedDriverList [ Index ]
def AddPayload ( self ,
UpdateImageTypeId ,
Payload = b ' ' ,
VendorCodeBytes = b ' ' ,
HardwareInstance = 0 ) :
self . _PayloadList . append ( ( UpdateImageTypeId , Payload , VendorCodeBytes ,
HardwareInstance ) )
def GetFmpCapsuleImageHeader ( self , Index ) :
if Index > = len ( self . _FmpCapsuleImageHeaderList ) :
raise ValueError
return self . _FmpCapsuleImageHeaderList [ Index ]
def Encode ( self ) :
self . EmbeddedDriverCount = len ( self . _EmbeddedDriverList )
self . PayloadItemCount = len ( self . _PayloadList )
FmpCapsuleHeader = struct . pack ( self . _StructFormat , self . Version ,
self . EmbeddedDriverCount ,
self . PayloadItemCount )
FmpCapsuleData = b ' '
Offset = self . _StructSize + (
self . EmbeddedDriverCount +
self . PayloadItemCount ) * self . _ItemOffsetSize
for EmbeddedDriver in self . _EmbeddedDriverList :
FmpCapsuleData = FmpCapsuleData + EmbeddedDriver
self . _ItemOffsetList . append ( Offset )
Offset = Offset + len ( EmbeddedDriver )
Index = 1
for ( UpdateImageTypeId , Payload , VendorCodeBytes ,
HardwareInstance ) in self . _PayloadList :
FmpCapsuleImageHeader = FmpCapsuleImageHeaderClass ( )
FmpCapsuleImageHeader . UpdateImageTypeId = UpdateImageTypeId
FmpCapsuleImageHeader . UpdateImageIndex = Index
FmpCapsuleImageHeader . Payload = Payload
FmpCapsuleImageHeader . VendorCodeBytes = VendorCodeBytes
FmpCapsuleImageHeader . UpdateHardwareInstance = HardwareInstance
FmpCapsuleImage = FmpCapsuleImageHeader . Encode ( )
FmpCapsuleData = FmpCapsuleData + FmpCapsuleImage
self . _ItemOffsetList . append ( Offset )
self . _FmpCapsuleImageHeaderList . append ( FmpCapsuleImageHeader )
Offset = Offset + len ( FmpCapsuleImage )
Index = Index + 1
for Offset in self . _ItemOffsetList :
FmpCapsuleHeader = FmpCapsuleHeader + struct . pack (
self . _ItemOffsetFormat , Offset )
self . _Valid = True
return FmpCapsuleHeader + FmpCapsuleData
def Decode ( self , Buffer ) :
if len ( Buffer ) < self . _StructSize :
raise ValueError
( Version , EmbeddedDriverCount , PayloadItemCount ) = struct . unpack (
self . _StructFormat , Buffer [ 0 : self . _StructSize ] )
if Version < self . EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION :
raise ValueError
self . Version = Version
self . EmbeddedDriverCount = EmbeddedDriverCount
self . PayloadItemCount = PayloadItemCount
self . _ItemOffsetList = [ ]
self . _EmbeddedDriverList = [ ]
self . _PayloadList = [ ]
self . _FmpCapsuleImageHeaderList = [ ]
#
# Parse the ItemOffsetList values
#
Offset = self . _StructSize
for Index in range ( 0 , EmbeddedDriverCount + PayloadItemCount ) :
ItemOffset = struct . unpack (
self . _ItemOffsetFormat ,
Buffer [ Offset : Offset + self . _ItemOffsetSize ] ) [ 0 ]
if ItemOffset > = len ( Buffer ) :
raise ValueError
self . _ItemOffsetList . append ( ItemOffset )
Offset = Offset + self . _ItemOffsetSize
Result = Buffer [ Offset : ]
#
# Parse the EmbeddedDrivers
#
for Index in range ( 0 , EmbeddedDriverCount ) :
Offset = self . _ItemOffsetList [ Index ]
if Index < ( len ( self . _ItemOffsetList ) - 1 ) :
Length = self . _ItemOffsetList [ Index + 1 ] - Offset
else :
Length = len ( Buffer ) - Offset
self . AddEmbeddedDriver ( Buffer [ Offset : Offset + Length ] )
#
# Parse the Payloads that are FMP Capsule Images
#
for Index in range ( EmbeddedDriverCount ,
EmbeddedDriverCount + PayloadItemCount ) :
Offset = self . _ItemOffsetList [ Index ]
if Index < ( len ( self . _ItemOffsetList ) - 1 ) :
Length = self . _ItemOffsetList [ Index + 1 ] - Offset
else :
Length = len ( Buffer ) - Offset
FmpCapsuleImageHeader = FmpCapsuleImageHeaderClass ( )
FmpCapsuleImageHeader . Decode ( Buffer [ Offset : Offset + Length ] )
self . AddPayload ( FmpCapsuleImageHeader . UpdateImageTypeId ,
FmpCapsuleImageHeader . Payload ,
FmpCapsuleImageHeader . VendorCodeBytes )
self . _FmpCapsuleImageHeaderList . append ( FmpCapsuleImageHeader )
self . _Valid = True
return Result
def DumpInfo ( self ) :
if not self . _Valid :
raise ValueError
print (
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER.Version = {Version:08X} ' . format (
Version = self . Version ) )
print (
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER.EmbeddedDriverCount = {EmbeddedDriverCount:08X} ' . format (
EmbeddedDriverCount = self . EmbeddedDriverCount ) )
print (
' EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER.PayloadItemCount = {PayloadItemCount:08X} ' . format (
PayloadItemCount = self . PayloadItemCount ) )
print ( ' EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER.ItemOffsetList = ' )
for Offset in self . _ItemOffsetList :
print ( ' {Offset:016X} ' . format ( Offset = Offset ) )
print ( ' ' )
for FmpCapsuleImageHeader in self . _FmpCapsuleImageHeaderList :
FmpCapsuleImageHeader . DumpInfo ( ' ' )
print ( ' ' )
2020-01-14 00:19:16 +08:00
def UnicodeStrToHexString ( Str ) :
return ( binascii . hexlify ( Str . encode ( ' utf-8 ' ) ) ) . decode ( )
2019-12-03 07:45:02 +08:00
def _SIGNATURE_32 ( A , B , C , D ) :
return struct . unpack ( ' =I ' , bytearray ( A + B + C + D , ' ascii ' ) ) [ 0 ]
def _SIGNATURE_32_TO_STRING ( Signature ) :
return struct . pack ( " <I " , Signature ) . decode ( )
class FmpPayloadHeaderClass ( object ) :
def __init__ ( self ) :
self . _Valid = False
self . Payload = b ' '
def Encode ( self ) :
self . _Valid = True
return self . Payload
def Decode ( self , Buffer ) :
self . Payload = Buffer [ 0 : ]
self . _Valid = True
return self . Payload
def DumpInfo ( self ) :
if not self . _Valid :
raise ValueError
print (
' FMP_PAYLOAD_HEADER.Signature = {Signature:08X} ( {SignatureString} ) ' . format (
Signature = self . Signature ,
SignatureString = _SIGNATURE_32_TO_STRING ( self . Signature ) ) )
print (
' FMP_PAYLOAD_HEADER.HeaderSize = {HeaderSize:08X} ' . format (
HeaderSize = self . HeaderSize ) )
print (
' FMP_PAYLOAD_HEADER.FwVersion = {FwVersion:08X} ' . format (
FwVersion = self . FwVersion ) )
print (
' FMP_PAYLOAD_HEADER.LowestSupportedVersion = {LowestSupportedVersion:08X} ' . format (
LowestSupportedVersion = self . LowestSupportedVersion ) )
print ( ' sizeof (Payload) = {Size:08X} ' . format (
Size = len ( self . Payload ) ) )
#
# GUID for firmware update image file
#
FIRMWARE_UPDATE_IMAGE_FILE_GUID = uuid . UUID ( ' { 1A3EAE58-B580-4fef-ACA3-A16D9E00DF5F} ' )
#0x1a3eae58, 0xb580, 0x4fef, 0xac, 0xa3, 0xa1, 0x6d, 0x9e, 0x0, 0xdf, 0x5f);
class Firmware_Update_Header ( Structure ) :
_fields_ = [
( ' FileGuid ' , ARRAY ( c_uint8 , 16 ) ) ,
( ' HeaderSize ' , c_uint32 ) ,
( ' FirmwreVersion ' , c_uint32 ) ,
( ' CapsuleFlags ' , c_uint32 ) ,
( ' PubKeyOffset ' , c_uint32 ) ,
( ' PubKeySize ' , c_uint32 ) ,
( ' ImageOffset ' , c_uint32 ) ,
( ' ImageSize ' , c_uint32 ) ,
( ' SignatureOffset ' , c_uint32 ) ,
( ' SignatureSize ' , c_uint32 ) ,
( ' Reserved ' , ARRAY ( c_uint32 , 3 ) )
]
2020-04-11 08:25:58 +08:00
def SignImage ( RawData , OutFile , HashType , SignScheme , PrivKey ) :
2019-12-03 07:45:02 +08:00
#
# Generate the new image layout
# 1. write firmware update header
#
unsigned_image = bytearray ( sizeof ( Firmware_Update_Header ) )
header = Firmware_Update_Header . from_buffer ( unsigned_image , 0 )
file_size = len ( RawData )
2019-12-11 14:06:24 +08:00
key_type = get_key_type ( PrivKey )
2019-12-09 07:17:32 +08:00
if key_type == ' RSA2048 ' :
key_size = 256
elif key_type == ' RSA3072 ' :
key_size = 384
2019-12-03 07:45:02 +08:00
header . FileGuid = ( c_ubyte * 16 ) . from_buffer_copy ( FIRMWARE_UPDATE_IMAGE_FILE_GUID . bytes_le )
header . HeaderSize = sizeof ( Firmware_Update_Header )
header . FirmwreVersion = 1
header . CapsuleFlags = 0
header . ImageOffset = header . HeaderSize
header . ImageSize = file_size
header . SignatureOffset = header . ImageOffset + header . ImageSize
2019-12-09 07:17:32 +08:00
header . SignatureSize = sizeof ( SIGNATURE_HDR ) + key_size
2019-12-03 07:45:02 +08:00
header . PubKeyOffset = header . SignatureOffset + header . SignatureSize
pubkey_file = ' fwu_public_key.bin '
gen_pub_key ( PrivKey , pubkey_file )
header . PubKeySize = os . path . getsize ( pubkey_file )
fwupdate_bin_file = ' fwupdate_unsigned.bin '
open ( fwupdate_bin_file , ' wb ' ) . write ( unsigned_image + RawData )
2020-04-11 08:25:58 +08:00
rsa_sign_file ( PrivKey , pubkey_file , HashType , SignScheme , fwupdate_bin_file , OutFile , True , True )
2019-12-03 07:45:02 +08:00
os . remove ( pubkey_file )
os . remove ( fwupdate_bin_file )
def main ( ) :
PredefinedUuidDict = {
' BIOS ' : ' 605C6813-C2C7-4242-9C27-50A4C363DBA4 ' , # SBL BIOS Region
2020-01-10 01:38:20 +08:00
' MISC ' : ' 66030B7A-47D1-4958-B73D-00B44B9DD4B6 ' , # SBL COMPONENT
2019-12-03 07:45:02 +08:00
' CSME ' : ' 43AEF186-0CA5-4230-B1BD-193FB4627201 ' , # IFWI ME/CSME
' CSMD ' : ' 4A467997-A909-4678-910C-E0FE1C9056EA ' , # CSME Update driver
2020-05-18 02:05:15 +08:00
' CMDI ' : ' 9034cab1-4d19-4856-a3cd-f074263c4a4d ' , # Command request
2019-12-03 07:45:02 +08:00
}
def ValidateUnsignedInteger ( Argument ) :
try :
Value = int ( Argument , 0 )
except :
Message = ' {Argument} is not a valid integer value. ' . format (
Argument = Argument )
raise argparse . ArgumentTypeError ( Message )
if Value < 0 :
Message = ' {Argument} is a negative value. ' . format (
Argument = Argument )
raise argparse . ArgumentTypeError ( Message )
return Value
def ValidateRegistryFormatGuid ( Argument ) :
try :
Value = uuid . UUID ( Argument )
except :
Message = ' {Argument} is not a valid registry format GUID value. ' . format (
Argument = Argument )
raise argparse . ArgumentTypeError ( Message )
return Value
#
# Create command line argument parser object
#
parser = argparse . ArgumentParser ( )
parser . add_argument ( ' -p ' , ' --payload ' , nargs = 2 , action = ' append ' , type = str , required = True , help = ' Specify payload information including GUID, FileName ' )
2020-06-09 06:58:21 +08:00
parser . add_argument ( ' -k ' , ' --priv_key ' , dest = ' PrivKey ' , type = str , required = True , help = ' Key Id or Private RSA 2048/RSA3072 key in PEM format to sign image ' )
2020-04-11 08:25:58 +08:00
parser . add_argument ( ' -a ' , ' --alg_hash ' , dest = ' HashType ' , type = str , choices = [ ' SHA2_256 ' , ' SHA2_384 ' ] , default = ' SHA2_256 ' , help = ' Hash type for signing ' )
parser . add_argument ( ' -s ' , ' --sign_scheme ' , dest = ' SignScheme ' , type = str , choices = [ ' RSA_PKCS1 ' , ' RSA_PSS ' ] , default = ' RSA_PSS ' , help = ' Signing Scheme types ' )
2019-12-03 07:45:02 +08:00
parser . add_argument ( ' -o ' , ' --output ' , dest = ' NewImage ' , type = str , required = True , help = ' Output file for signed image ' )
parser . add_argument ( " -v " , " --verbose " , dest = ' Verbose ' , action = " store_true " , help = " Turn on verbose output with informational messages printed, including capsule headers and warning messages. " )
#
# Parse command line arguments
#
args = parser . parse_args ( )
FmpCapsuleHeader = FmpCapsuleHeaderClass ( )
for PldUuid , PldFile in args . payload :
FmpPayloadHeader = FmpPayloadHeaderClass ( )
Buffer = open ( PldFile , ' rb ' ) . read ( )
Result = Buffer
FmpPayloadHeader . Payload = Result
Result = FmpPayloadHeader . Encode ( )
if PldUuid in PredefinedUuidDict :
2020-01-14 00:19:16 +08:00
HardwareInstance = ' 00000000 ' + UnicodeStrToHexString ( PldUuid [ : : - 1 ] )
2019-12-03 07:45:02 +08:00
PldUuid = PredefinedUuidDict [ PldUuid ]
2020-01-10 01:38:20 +08:00
else :
CompName = PldUuid . upper ( )
if " : " in CompName :
items = CompName . split ( " : " )
item_cnt = len ( items )
if item_cnt > 2 :
raise Exception ( ' more than 2 strings in component descriptor ' )
if len ( items [ 0 ] ) != 4 or len ( items [ 1 ] ) != 4 :
raise Exception ( ' %s is not a 4 character string ' % CompName )
2020-01-14 00:19:16 +08:00
ContainerCompName = UnicodeStrToHexString ( items [ 0 ] [ : : - 1 ] )
SblComponentName = UnicodeStrToHexString ( items [ 1 ] [ : : - 1 ] )
2020-01-10 01:38:20 +08:00
else :
if len ( CompName ) != 4 :
raise Exception ( ' %s is not a 4 character string ' % CompName )
ContainerCompName = ' 00000000 '
2020-01-14 00:19:16 +08:00
SblComponentName = UnicodeStrToHexString ( CompName [ : : - 1 ] )
2020-01-10 01:38:20 +08:00
HardwareInstance = ContainerCompName + SblComponentName
PldUuid = PredefinedUuidDict [ ' MISC ' ]
HardwareInstance = int ( HardwareInstance , 16 )
2019-12-03 07:45:02 +08:00
Guid = ValidateRegistryFormatGuid ( PldUuid )
2020-01-10 01:38:20 +08:00
FmpCapsuleHeader . AddPayload ( Guid , Result , ' ' , HardwareInstance )
2019-12-03 07:45:02 +08:00
Result = FmpCapsuleHeader . Encode ( )
#
# Write binary output file
#
if args . Verbose :
FmpCapsuleHeader . DumpInfo ( )
#
# Create final capsule
#
2020-04-11 08:25:58 +08:00
SignImage ( Result , args . NewImage , args . HashType , args . SignScheme , args . PrivKey )
2019-12-03 07:45:02 +08:00
print ( ' Success ' )
if __name__ == ' __main__ ' :
sys . exit ( main ( ) )