mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-11-27 12:15:19 +01:00
251 lines
10 KiB
Python
Executable File
251 lines
10 KiB
Python
Executable File
## @file
|
|
# generate capsule
|
|
#
|
|
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
##
|
|
# Import Modules
|
|
#
|
|
from __future__ import absolute_import
|
|
from .GenFdsGlobalVariable import GenFdsGlobalVariable, FindExtendTool
|
|
from CommonDataClass.FdfClass import CapsuleClassObject
|
|
import Common.LongFilePathOs as os
|
|
from io import BytesIO
|
|
from Common.Misc import SaveFileOnChange, PackGUID
|
|
import uuid
|
|
from struct import pack
|
|
from Common import EdkLogger
|
|
from Common.BuildToolError import GENFDS_ERROR
|
|
from Common.DataType import TAB_LINE_BREAK
|
|
|
|
WIN_CERT_REVISION = 0x0200
|
|
WIN_CERT_TYPE_EFI_GUID = 0x0EF1
|
|
EFI_CERT_TYPE_PKCS7_GUID = uuid.UUID('{4aafd29d-68df-49ee-8aa9-347d375665a7}')
|
|
EFI_CERT_TYPE_RSA2048_SHA256_GUID = uuid.UUID('{a7717414-c616-4977-9420-844712a735bf}')
|
|
|
|
## create inf file describes what goes into capsule and call GenFv to generate capsule
|
|
#
|
|
#
|
|
class Capsule (CapsuleClassObject):
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def __init__(self):
|
|
CapsuleClassObject.__init__(self)
|
|
# For GenFv
|
|
self.BlockSize = None
|
|
# For GenFv
|
|
self.BlockNum = None
|
|
self.CapsuleName = None
|
|
|
|
## Generate FMP capsule
|
|
#
|
|
# @retval string Generated Capsule file path
|
|
#
|
|
def GenFmpCapsule(self):
|
|
#
|
|
# Generate capsule header
|
|
# typedef struct {
|
|
# EFI_GUID CapsuleGuid;
|
|
# UINT32 HeaderSize;
|
|
# UINT32 Flags;
|
|
# UINT32 CapsuleImageSize;
|
|
# } EFI_CAPSULE_HEADER;
|
|
#
|
|
Header = BytesIO()
|
|
#
|
|
# Use FMP capsule GUID: 6DCBD5ED-E82D-4C44-BDA1-7194199AD92A
|
|
#
|
|
Header.write(PackGUID('6DCBD5ED-E82D-4C44-BDA1-7194199AD92A'.split('-')))
|
|
HdrSize = 0
|
|
if 'CAPSULE_HEADER_SIZE' in self.TokensDict:
|
|
Header.write(pack('=I', int(self.TokensDict['CAPSULE_HEADER_SIZE'], 16)))
|
|
HdrSize = int(self.TokensDict['CAPSULE_HEADER_SIZE'], 16)
|
|
else:
|
|
Header.write(pack('=I', 0x20))
|
|
HdrSize = 0x20
|
|
Flags = 0
|
|
if 'CAPSULE_FLAGS' in self.TokensDict:
|
|
for flag in self.TokensDict['CAPSULE_FLAGS'].split(','):
|
|
flag = flag.strip()
|
|
if flag == 'PopulateSystemTable':
|
|
Flags |= 0x00010000 | 0x00020000
|
|
elif flag == 'PersistAcrossReset':
|
|
Flags |= 0x00010000
|
|
elif flag == 'InitiateReset':
|
|
Flags |= 0x00040000
|
|
Header.write(pack('=I', Flags))
|
|
#
|
|
# typedef struct {
|
|
# UINT32 Version;
|
|
# UINT16 EmbeddedDriverCount;
|
|
# UINT16 PayloadItemCount;
|
|
# // UINT64 ItemOffsetList[];
|
|
# } EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER;
|
|
#
|
|
FwMgrHdr = BytesIO()
|
|
if 'CAPSULE_HEADER_INIT_VERSION' in self.TokensDict:
|
|
FwMgrHdr.write(pack('=I', int(self.TokensDict['CAPSULE_HEADER_INIT_VERSION'], 16)))
|
|
else:
|
|
FwMgrHdr.write(pack('=I', 0x00000001))
|
|
FwMgrHdr.write(pack('=HH', len(self.CapsuleDataList), len(self.FmpPayloadList)))
|
|
FwMgrHdrSize = 4+2+2+8*(len(self.CapsuleDataList)+len(self.FmpPayloadList))
|
|
|
|
#
|
|
# typedef struct _WIN_CERTIFICATE {
|
|
# UINT32 dwLength;
|
|
# UINT16 wRevision;
|
|
# UINT16 wCertificateType;
|
|
# //UINT8 bCertificate[ANYSIZE_ARRAY];
|
|
# } WIN_CERTIFICATE;
|
|
#
|
|
# typedef struct _WIN_CERTIFICATE_UEFI_GUID {
|
|
# WIN_CERTIFICATE Hdr;
|
|
# EFI_GUID CertType;
|
|
# //UINT8 CertData[ANYSIZE_ARRAY];
|
|
# } WIN_CERTIFICATE_UEFI_GUID;
|
|
#
|
|
# typedef struct {
|
|
# UINT64 MonotonicCount;
|
|
# WIN_CERTIFICATE_UEFI_GUID AuthInfo;
|
|
# } EFI_FIRMWARE_IMAGE_AUTHENTICATION;
|
|
#
|
|
# typedef struct _EFI_CERT_BLOCK_RSA_2048_SHA256 {
|
|
# EFI_GUID HashType;
|
|
# UINT8 PublicKey[256];
|
|
# UINT8 Signature[256];
|
|
# } EFI_CERT_BLOCK_RSA_2048_SHA256;
|
|
#
|
|
|
|
PreSize = FwMgrHdrSize
|
|
Content = BytesIO()
|
|
for driver in self.CapsuleDataList:
|
|
FileName = driver.GenCapsuleSubItem()
|
|
FwMgrHdr.write(pack('=Q', PreSize))
|
|
PreSize += os.path.getsize(FileName)
|
|
File = open(FileName, 'rb')
|
|
Content.write(File.read())
|
|
File.close()
|
|
for fmp in self.FmpPayloadList:
|
|
if fmp.Existed:
|
|
FwMgrHdr.write(pack('=Q', PreSize))
|
|
PreSize += len(fmp.Buffer)
|
|
Content.write(fmp.Buffer)
|
|
continue
|
|
if fmp.ImageFile:
|
|
for Obj in fmp.ImageFile:
|
|
fmp.ImageFile = Obj.GenCapsuleSubItem()
|
|
if fmp.VendorCodeFile:
|
|
for Obj in fmp.VendorCodeFile:
|
|
fmp.VendorCodeFile = Obj.GenCapsuleSubItem()
|
|
if fmp.Certificate_Guid:
|
|
ExternalTool, ExternalOption = FindExtendTool([], GenFdsGlobalVariable.ArchList, fmp.Certificate_Guid)
|
|
CmdOption = ''
|
|
CapInputFile = fmp.ImageFile
|
|
if not os.path.isabs(fmp.ImageFile):
|
|
CapInputFile = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, fmp.ImageFile)
|
|
CapOutputTmp = os.path.join(GenFdsGlobalVariable.FvDir, self.UiCapsuleName) + '.tmp'
|
|
if ExternalTool is None:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "No tool found with GUID %s" % fmp.Certificate_Guid)
|
|
else:
|
|
CmdOption += ExternalTool
|
|
if ExternalOption:
|
|
CmdOption = CmdOption + ' ' + ExternalOption
|
|
CmdOption += ' -e ' + ' --monotonic-count ' + str(fmp.MonotonicCount) + ' -o ' + CapOutputTmp + ' ' + CapInputFile
|
|
CmdList = CmdOption.split()
|
|
GenFdsGlobalVariable.CallExternalTool(CmdList, "Failed to generate FMP auth capsule")
|
|
if uuid.UUID(fmp.Certificate_Guid) == EFI_CERT_TYPE_PKCS7_GUID:
|
|
dwLength = 4 + 2 + 2 + 16 + os.path.getsize(CapOutputTmp) - os.path.getsize(CapInputFile)
|
|
else:
|
|
dwLength = 4 + 2 + 2 + 16 + 16 + 256 + 256
|
|
fmp.ImageFile = CapOutputTmp
|
|
AuthData = [fmp.MonotonicCount, dwLength, WIN_CERT_REVISION, WIN_CERT_TYPE_EFI_GUID, fmp.Certificate_Guid]
|
|
fmp.Buffer = fmp.GenCapsuleSubItem(AuthData)
|
|
else:
|
|
fmp.Buffer = fmp.GenCapsuleSubItem()
|
|
FwMgrHdr.write(pack('=Q', PreSize))
|
|
PreSize += len(fmp.Buffer)
|
|
Content.write(fmp.Buffer)
|
|
BodySize = len(FwMgrHdr.getvalue()) + len(Content.getvalue())
|
|
Header.write(pack('=I', HdrSize + BodySize))
|
|
#
|
|
# The real capsule header structure is 28 bytes
|
|
#
|
|
Header.write(b'\x00'*(HdrSize-28))
|
|
Header.write(FwMgrHdr.getvalue())
|
|
Header.write(Content.getvalue())
|
|
#
|
|
# Generate FMP capsule file
|
|
#
|
|
CapOutputFile = os.path.join(GenFdsGlobalVariable.FvDir, self.UiCapsuleName) + '.Cap'
|
|
SaveFileOnChange(CapOutputFile, Header.getvalue(), True)
|
|
return CapOutputFile
|
|
|
|
## Generate capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @retval string Generated Capsule file path
|
|
#
|
|
def GenCapsule(self):
|
|
if self.UiCapsuleName.upper() + 'cap' in GenFdsGlobalVariable.ImageBinDict:
|
|
return GenFdsGlobalVariable.ImageBinDict[self.UiCapsuleName.upper() + 'cap']
|
|
|
|
GenFdsGlobalVariable.InfLogger( "\nGenerate %s Capsule" %self.UiCapsuleName)
|
|
if ('CAPSULE_GUID' in self.TokensDict and
|
|
uuid.UUID(self.TokensDict['CAPSULE_GUID']) == uuid.UUID('6DCBD5ED-E82D-4C44-BDA1-7194199AD92A')):
|
|
return self.GenFmpCapsule()
|
|
|
|
CapInfFile = self.GenCapInf()
|
|
CapInfFile.append("[files]" + TAB_LINE_BREAK)
|
|
CapFileList = []
|
|
for CapsuleDataObj in self.CapsuleDataList:
|
|
CapsuleDataObj.CapsuleName = self.CapsuleName
|
|
FileName = CapsuleDataObj.GenCapsuleSubItem()
|
|
CapsuleDataObj.CapsuleName = None
|
|
CapFileList.append(FileName)
|
|
CapInfFile.append("EFI_FILE_NAME = " + \
|
|
FileName + \
|
|
TAB_LINE_BREAK)
|
|
SaveFileOnChange(self.CapInfFileName, ''.join(CapInfFile), False)
|
|
#
|
|
# Call GenFv tool to generate capsule
|
|
#
|
|
CapOutputFile = os.path.join(GenFdsGlobalVariable.FvDir, self.UiCapsuleName)
|
|
CapOutputFile = CapOutputFile + '.Cap'
|
|
GenFdsGlobalVariable.GenerateFirmwareVolume(
|
|
CapOutputFile,
|
|
[self.CapInfFileName],
|
|
Capsule=True,
|
|
FfsList=CapFileList
|
|
)
|
|
|
|
GenFdsGlobalVariable.VerboseLogger( "\nGenerate %s Capsule Successfully" %self.UiCapsuleName)
|
|
GenFdsGlobalVariable.SharpCounter = 0
|
|
GenFdsGlobalVariable.ImageBinDict[self.UiCapsuleName.upper() + 'cap'] = CapOutputFile
|
|
return CapOutputFile
|
|
|
|
## Generate inf file for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @retval file inf file object
|
|
#
|
|
def GenCapInf(self):
|
|
self.CapInfFileName = os.path.join(GenFdsGlobalVariable.FvDir,
|
|
self.UiCapsuleName + "_Cap" + '.inf')
|
|
CapInfFile = []
|
|
|
|
CapInfFile.append("[options]" + TAB_LINE_BREAK)
|
|
|
|
for Item in self.TokensDict:
|
|
CapInfFile.append("EFI_" + \
|
|
Item + \
|
|
' = ' + \
|
|
self.TokensDict[Item] + \
|
|
TAB_LINE_BREAK)
|
|
|
|
return CapInfFile
|