[edk2-devel] [PATCH v3 1/1] BaseTools/Capsule: Tool to Generate Windows Firmware Update Driver
Liming Gao
liming.gao at intel.com
Thu Jun 13 03:09:57 UTC 2019
Eric:
Can you help post link for Windows Firmware Update Drivers?
Thanks
Liming
>-----Original Message-----
>From: devel at edk2.groups.io [mailto:devel at edk2.groups.io] On Behalf Of Eric
>Jin
>Sent: Tuesday, June 11, 2019 2:23 PM
>To: devel at edk2.groups.io
>Cc: Feng, Bob C <bob.c.feng at intel.com>; Gao, Liming
><liming.gao at intel.com>; Kinney, Michael D <michael.d.kinney at intel.com>
>Subject: [edk2-devel] [PATCH v3 1/1] BaseTools/Capsule: Tool to Generate
>Windows Firmware Update Driver
>
>https://bugzilla.tianocore.org/show_bug.cgi?id=1837
>
>The tool is designed to generate Windows Firmware Update Drivers, the
>input is one drivername.cap with related parameters, the output Windows
>Driver package are composed by drivername.cap, drivername.inf and
>drivername.cat to update the single payload in device.
>
>usage:
>GenerateWindowsDriver [-h] [--output-folder OUTPUTFOLDER]
> [--product-fmp-guid PRODUCTFMPGUID]
> [--capsuleversion-dotstring CAPSULEVERSION_DOTSTRING]
> [--capsuleversion-hexstring CAPSULEVERSION_HEXSTRING]
> [--product-fw-provider PRODUCTFWPROVIDER]
> [--product-fw-mfg-name PRODUCTFWMFGNAME]
> [--product-fw-desc PRODUCTFWDESC]
> [--capsule-file-name CAPSULEFILENAME]
> [--pfx-file PFXFILE] [--arch ARCH]
> [--operating-system-string OPERATINGSYSTEMSTRING]
>
>Cc: Bob Feng <bob.c.feng at intel.com>
>Cc: Liming Gao <liming.gao at intel.com>
>Cc: Kinney Michael D <michael.d.kinney at intel.com>
>Signed-off-by: Eric Jin <eric.jin at intel.com>
>---
> BaseTools/Source/Python/Capsule/CatGenerator.py | 159
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/Capsule/GenerateWindowsDriver.py | 114
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/Capsule/InfGenerator.py | 210
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/Capsule/WindowsCapsuleSupportHelper.py | 102
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 585 insertions(+)
>
>diff --git a/BaseTools/Source/Python/Capsule/CatGenerator.py
>b/BaseTools/Source/Python/Capsule/CatGenerator.py
>new file mode 100644
>index 0000000000..5f7fefa788
>--- /dev/null
>+++ b/BaseTools/Source/Python/Capsule/CatGenerator.py
>@@ -0,0 +1,159 @@
>+## @file
>+ # Script to generate Cat files for capsule update based on supplied inf file
>+ #
>+ # Copyright (c) 2019, Microsoft Corporation
>+ # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
>+ # SPDX-License-Identifier: BSD-2-Clause-Patent
>+ #
>+ ##
>+
>+import os
>+import logging
>+import datetime
>+import subprocess
>+import threading
>+
>+class PropagatingThread(threading.Thread):
>+ def run(self):
>+ self.exc = None
>+ try:
>+ if hasattr(self, '_Thread__target'):
>+ # Thread uses name mangling prior to Python 3.
>+ self.ret = self._Thread__target(*self._Thread__args,
>**self._Thread__kwargs)
>+ else:
>+ self.ret = self._target(*self._args, **self._kwargs)
>+ except BaseException as e:
>+ self.exc = e
>+ def join(self, timeout=None):
>+ super(PropagatingThread, self).join()
>+ if self.exc:
>+ raise self.exc
>+ return self.ret
>+def reader(filepath, outstream, stream):
>+ if filepath:
>+ try:
>+ with open(filepath, "w") as f:
>+ print("The file is" + filepath)
>+ except FileNotFoundError:
>+ print("Sorry, the file" + filepath + "does not exist.")
>+
>+ while True:
>+ s = stream.readline().decode()
>+ if not s:
>+ stream.close()
>+ break
>+ # write to file if caller provideds file
>+ if filepath:
>+ try:
>+ with open(filepath, "a") as f:
>+ f.write(s)
>+ except FileNotFoundError:
>+ print("Sorry, the file" + filepath + "does not exist.")
>+ if(outstream is not None):
>+ # write to stream object if caller provided object
>+ outstream.write(s)
>+ logging.info(s.rstrip())
>+
>+def RunCmd(cmd, parameters, capture=True, workingdir=None,
>outfile=None, outstream=None, environ=None):
>+ cmd = cmd.strip('"\'')
>+ if " " in cmd:
>+ cmd = '"' + cmd + '"'
>+ if parameters is not None:
>+ parameters = parameters.strip()
>+ cmd += " " + parameters
>+ starttime = datetime.datetime.now()
>+ logging.info("Cmd to run is: " + cmd)
>+ logging.info("------------------------------------------------")
>+ logging.info("--------------Cmd Output Starting---------------")
>+ logging.info("------------------------------------------------")
>+ c = subprocess.Popen(cmd, stdout=subprocess.PIPE,
>stderr=subprocess.STDOUT, cwd=workingdir, shell=True, env=environ)
>+ if(capture):
>+ outr = PropagatingThread(target=reader, args=(outfile, outstream,
>c.stdout,))
>+ outr.start()
>+ outr.join()
>+ c.wait()
>+
>+ endtime = datetime.datetime.now()
>+ delta = endtime - starttime
>+ logging.info("------------------------------------------------")
>+ logging.info("--------------Cmd Output Finished---------------")
>+ logging.info("--------- Running Time (mm:ss): {0[0]:02}:{0[1]:02} ----------
>".format(divmod(delta.seconds, 60)))
>+ logging.info("------------------------------------------------")
>+ return c.returncode
>+
>+class CatGenerator(object):
>+ SUPPORTED_OS = {'win10': '10',
>+ '10': '10',
>+ '10_au': '10_AU',
>+ '10_rs2': '10_RS2',
>+ '10_rs3': '10_RS3',
>+ '10_rs4': '10_RS4',
>+ 'server10': 'Server10',
>+ 'server2016': 'Server2016',
>+ 'serverrs2': 'ServerRS2',
>+ 'serverrs3': 'ServerRS3',
>+ 'serverrs4': 'ServerRS4'
>+ }
>+
>+ def __init__(self, arch, os):
>+ self.Arch = arch
>+ self.OperatingSystem = os
>+
>+ @property
>+ def Arch(self):
>+ return self._arch
>+
>+ @Arch.setter
>+ def Arch(self, value):
>+ value = value.lower()
>+ if(value == "x64") or (value == "amd64"): # support amd64 value so INF
>and CAT tools can use same arch value
>+ self._arch = "X64"
>+ elif(value == "arm"):
>+ self._arch = "ARM"
>+ elif(value == "arm64") or (value == "aarch64"): # support UEFI defined
>aarch64 value as well
>+ self._arch = "ARM64"
>+ else:
>+ logging.critical("Unsupported Architecture: %s", value)
>+ raise ValueError("Unsupported Architecture")
>+
>+ @property
>+ def OperatingSystem(self):
>+ return self._operatingsystem
>+
>+ @OperatingSystem.setter
>+ def OperatingSystem(self, value):
>+ key = value.lower()
>+ if(key not in CatGenerator.SUPPORTED_OS.keys()):
>+ logging.critical("Unsupported Operating System: %s", key)
>+ raise ValueError("Unsupported Operating System")
>+ self._operatingsystem = CatGenerator.SUPPORTED_OS[key]
>+
>+ def MakeCat(self, OutputCatFile, PathToInf2CatTool=None):
>+ # Find Inf2Cat tool
>+ if(PathToInf2CatTool is None):
>+ PathToInf2CatTool = os.path.join(os.getenv("ProgramFiles(x86)"),
>"Windows Kits", "10",
>+ "bin", "x86", "Inf2Cat.exe")
>+ if not os.path.exists(PathToInf2CatTool):
>+ logging.debug("Windows Kit 10 not Found....trying 8.1")
>+ # Try 8.1 kit
>+ PathToInf2CatTool.replace("10", "8.1")
>+
>+ # check if exists
>+ if not os.path.exists(PathToInf2CatTool):
>+ raise Exception("Can't find Inf2Cat on this machine. Please install the
>Windows 10 WDK - "
>+ "https://developer.microsoft.com/en-
>us/windows/hardware/windows-driver-kit")
>+
>+ # Adjust for spaces in the path (when calling the command).
>+ if " " in PathToInf2CatTool:
>+ PathToInf2CatTool = '"' + PathToInf2CatTool + '"'
>+
>+ OutputFolder = os.path.dirname(OutputCatFile)
>+ # Make Cat file
>+ cmd = "/driver:. /os:" + self.OperatingSystem + "_" + self.Arch + "
>/verbose"
>+ ret = RunCmd(PathToInf2CatTool, cmd, workingdir=OutputFolder)
>+ if(ret != 0):
>+ raise Exception("Creating Cat file Failed with errorcode %d" % ret)
>+ if(not os.path.isfile(OutputCatFile)):
>+ raise Exception("CAT file (%s) not created" % OutputCatFile)
>+
>+ return 0
>diff --git a/BaseTools/Source/Python/Capsule/GenerateWindowsDriver.py
>b/BaseTools/Source/Python/Capsule/GenerateWindowsDriver.py
>new file mode 100644
>index 0000000000..83546f69fb
>--- /dev/null
>+++ b/BaseTools/Source/Python/Capsule/GenerateWindowsDriver.py
>@@ -0,0 +1,114 @@
>+## @file
>+# Generate a capsule windows driver.
>+#
>+# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
>+# SPDX-License-Identifier: BSD-2-Clause-Patent
>+#
>+
>+'''
>+GenerateWindowsDriver
>+'''
>+
>+import sys
>+import argparse
>+import uuid
>+import struct
>+import subprocess
>+import os
>+import tempfile
>+import shutil
>+import platform
>+import re
>+import logging
>+from WindowsCapsuleSupportHelper import
>WindowsCapsuleSupportHelper
>+
>+#
>+# Globals for help information
>+#
>+__prog__ = 'GenerateWindowsDriver'
>+__version__ = '0.0'
>+__copyright__ = 'Copyright (c) 2019, Intel Corporation. All rights reserved.'
>+__description__ = 'Generate Capsule Windows Driver.\n'
>+
>+
>+if __name__ == '__main__':
>+ def convert_arg_line_to_args(arg_line):
>+ for arg in arg_line.split():
>+ if not arg.strip():
>+ continue
>+ yield arg
>+
>+ parser = argparse.ArgumentParser (
>+ prog = __prog__,
>+ description = __description__ + __copyright__,
>+ conflict_handler = 'resolve',
>+ fromfile_prefix_chars = '@'
>+ )
>+ parser.convert_arg_line_to_args = convert_arg_line_to_args
>+ parser.add_argument("--output-folder", dest = 'OutputFolder', help =
>"firmware resource update driver package output folder.")
>+ parser.add_argument("--product-fmp-guid", dest = 'ProductFmpGuid',
>help = "firmware GUID of resource update driver package")
>+ parser.add_argument("--capsuleversion-dotstring", dest =
>'CapsuleVersion_DotString', help = "firmware version with date on which
>update driver package is authored")
>+ parser.add_argument("--capsuleversion-hexstring", dest =
>'CapsuleVersion_HexString', help = "firmware version in Hex of update driver
>package")
>+ parser.add_argument("--product-fw-provider", dest =
>'ProductFwProvider', help = "vendor/provider of entire firmware resource
>update driver package")
>+ parser.add_argument("--product-fw-mfg-name", dest =
>'ProductFwMfgName', help = "manufacturer/vendor of firmware resource
>update driver package")
>+ parser.add_argument("--product-fw-desc", dest = "ProductFwDesc", help
>= "description about resource update driver")
>+ parser.add_argument("--capsule-file-name", dest = 'CapsuleFileName',
>help ="firmware resource image file")
>+ parser.add_argument("--pfx-file", dest = 'PfxFile', help = "pfx file path
>used to sign resource update driver")
>+ parser.add_argument("--arch", dest = 'Arch', help = "supported
>architecture:arm/x64/amd64/arm64/aarch64", default = 'amd64')
>+ parser.add_argument("--operating-system-string", dest =
>'OperatingSystemString', help = "supported operating
>system:win10/10/10_au/10_rs2/10_rs3/10_rs4/server10/server2016/serverrs
>2/serverrs3/serverrs4", default = "win10")
>+
>+ def ArgCheck(args):
>+ Version = args.CapsuleVersion_DotString.split('.')
>+
>+ if len(Version) != 4:
>+ logging.critical("Name invalid: '%s'", args.CapsuleVersion_DotString)
>+ raise ValueError("Name invalid.")
>+ for sub in Version:
>+ if int(sub) > 65536:
>+ logging.critical("Name invalid: '%s'", args.CapsuleVersion_DotString)
>+ raise ValueError("Name exceed limit 65536.")
>+
>+ if not (re.compile(r'[0-9.]*$')).match(args.CapsuleVersion_DotString):
>+ logging.critical("Name invalid: '%s'", args.CapsuleVersion_DotString)
>+ raise ValueError("Name has invalid chars.")
>+
>+ def CapsuleGuidCheck(InputFile, Guid):
>+ TempCapDecode = 'TempCapDecode.txt'
>+ Command = 'python GenerateCapsule.py "' + InputFile + '" --dump-
>info >' + TempCapDecode
>+ os.system (Command)
>+ with open(TempCapDecode, 'rb') as f:
>+ for line in f:
>+ if re.search(b'UpdateImageTypeId', line, re.M|re.I):
>+ CapGuid = str(line).split('= ')[1][:-5]
>+ break
>+ os.remove(TempCapDecode)
>+ if (Guid != CapGuid):
>+ print('GenerateWindowsDriver error: Different Guid from Capsule')
>+ sys.exit(1)
>+
>+ args = parser.parse_args()
>+
>+ InputFile = os.path.join(args.OutputFolder, '') + args.CapsuleFileName
>+
>+ ProductName = args.CapsuleFileName.strip('.cap')
>+ WindowsDriver = WindowsCapsuleSupportHelper ()
>+
>+ ArgCheck(args)
>+ CapsuleGuidCheck(InputFile, args.ProductFmpGuid)
>+
>+ WindowsDriver.PackageWindowsCapsuleFiles (
>+ args.OutputFolder,
>+ ProductName,
>+ args.ProductFmpGuid,
>+ args.CapsuleVersion_DotString,
>+ args.CapsuleVersion_HexString,
>+ args.ProductFwProvider,
>+ args.ProductFwMfgName,
>+ args.ProductFwDesc,
>+ args.CapsuleFileName,
>+ args.PfxFile,
>+ None,
>+ None,
>+ args.Arch,
>+ args.OperatingSystemString
>+ )
>diff --git a/BaseTools/Source/Python/Capsule/InfGenerator.py
>b/BaseTools/Source/Python/Capsule/InfGenerator.py
>new file mode 100644
>index 0000000000..508bbed0ef
>--- /dev/null
>+++ b/BaseTools/Source/Python/Capsule/InfGenerator.py
>@@ -0,0 +1,210 @@
>+## @file
>+ # Script to generate inf files for capsule update based on INF TEMPLATE and
>+ # supplied information (Name, Version, ESRT Guid, Rollback, etc.)
>+ #
>+ # Copyright (c) 2019, Microsoft Corporation
>+ # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
>+ # SPDX-License-Identifier: BSD-2-Clause-Patent
>+ ##
>+
>+import os
>+import logging
>+import datetime
>+import re
>+import uuid
>+
>+
>+#####
>+#
>+#####
>+class InfGenerator(object):
>+
>+ ### INF Template ###
>+ TEMPLATE = r""";
>+; {Name}.inf
>+; {DriverVersion}
>+; Copyright (C) 2019 Microsoft Corporation. All Rights Reserved.
>+;
>+[Version]
>+Signature="$WINDOWS NT$"
>+Class=Firmware
>+ClassGuid={{f2e7dd72-6468-4e36-b6f1-6488f42c1b52}}
>+Provider=%Provider%
>+DriverVer={Date},{DriverVersion}
>+PnpLockdown=1
>+CatalogFile={Name}.cat
>+[Manufacturer]
>+%MfgName% = Firmware,NT{Arch}
>+[Firmware.NT{Arch}]
>+%FirmwareDesc% = Firmware_Install,UEFI\RES_{{{EsrtGuid}}}
>+[Firmware_Install.NT]
>+CopyFiles = Firmware_CopyFiles
>+{Rollback}
>+[Firmware_CopyFiles]
>+{FirmwareBinFile}
>+[Firmware_Install.NT.Hw]
>+AddReg = Firmware_AddReg
>+[Firmware_AddReg]
>+HKR,,FirmwareId,,{{{EsrtGuid}}}
>+HKR,,FirmwareVersion,%REG_DWORD%,{VersionHexString}
>+HKR,,FirmwareFilename,,{FirmwareBinFile}
>+[SourceDisksNames]
>+1 = %DiskName%
>+[SourceDisksFiles]
>+{FirmwareBinFile} = 1
>+[DestinationDirs]
>+DefaultDestDir = %DIRID_WINDOWS%,Firmware ; %SystemRoot%\Firmware
>+[Strings]
>+; localizable
>+Provider = "{Provider}"
>+MfgName = "{MfgName}"
>+FirmwareDesc = "{Description}"
>+DiskName = "Firmware Update"
>+; non-localizable
>+DIRID_WINDOWS = 10
>+REG_DWORD = 0x00010001
>+"""
>+
>+ ROLLBACKTEMPLATE = r"""AddReg =
>Firmware_DowngradePolicy_Addreg
>+ ;override firmware resource update policy to allow downgrade to lower
>version
>+ [Firmware_DowngradePolicy_Addreg]
>+
>HKLM,SYSTEM\CurrentControlSet\Control\FirmwareResources\{{{EsrtGuid}}},
>Policy,%REG_DWORD%,1
>+ """
>+
>+ SUPPORTED_ARCH = {'amd64': 'amd64',
>+ 'x64': 'amd64',
>+ 'arm': 'arm',
>+ 'arm64': 'ARM64',
>+ 'aarch64': 'ARM64'
>+ }
>+
>+ def __init__(self, name_string, provider, esrt_guid, arch,
>description_string, version_string, version_hex):
>+ self.Name = name_string
>+ self.Provider = provider
>+ self.EsrtGuid = esrt_guid
>+ self.Arch = arch
>+ self.Description = description_string
>+ self.VersionString = version_string
>+ self.VersionHex = version_hex
>+ self._manufacturer = None # default for optional feature
>+ self._date = datetime.date.today()
>+
>+ @property
>+ def Name(self):
>+ return self._name
>+
>+ @Name.setter
>+ def Name(self, value):
>+ # test here for invalid chars
>+ if not (re.compile(r'[\w-]*$')).match(value):
>+ logging.critical("Name invalid: '%s'", value)
>+ raise ValueError("Name has invalid chars.")
>+ self._name = value
>+
>+ @property
>+ def Provider(self):
>+ return self._provider
>+
>+ @Provider.setter
>+ def Provider(self, value):
>+ self._provider = value
>+
>+ @property
>+ def Manufacturer(self):
>+ if(self._manufacturer is None):
>+ return self.Provider
>+
>+ return self._manufacturer
>+
>+ @Manufacturer.setter
>+ def Manufacturer(self, value):
>+ self._manufacturer = value
>+
>+ @property
>+ def Description(self):
>+ return self._description
>+
>+ @Description.setter
>+ def Description(self, value):
>+ self._description = value
>+
>+ @property
>+ def EsrtGuid(self):
>+ return self._esrtguid
>+
>+ @EsrtGuid.setter
>+ def EsrtGuid(self, value):
>+ uuid.UUID(value) # if this works it is valid...otherwise throws exception
>+ # todo - make sure it is formatted exactly right
>+ self._esrtguid = value
>+
>+ @property
>+ def VersionString(self):
>+ return self._versionstring
>+
>+ @VersionString.setter
>+ def VersionString(self, value):
>+ c = value.count(".")
>+ if(c < 1) or (c > 3):
>+ logging.critical("Version string in invalid format.")
>+ raise ValueError("VersionString must be in format of xx.xx ->
>xx.xx.xx.xx")
>+ self._versionstring = value
>+
>+ @property
>+ def VersionHex(self):
>+ return "0x%08X" % self._versionhex
>+
>+ @VersionHex.setter
>+ def VersionHex(self, value):
>+ a = int(value, 0)
>+ if(a > 0xFFFFFFFF):
>+ logging.critical("VersionHex invalid: '%s'", value)
>+ raise ValueError("VersionHex must fit within 32bit value range for
>unsigned integer")
>+ self._versionhex = a
>+
>+ @property
>+ def Arch(self):
>+ return self._arch
>+
>+ @Arch.setter
>+ def Arch(self, value):
>+ key = value.lower()
>+ if(key not in InfGenerator.SUPPORTED_ARCH.keys()):
>+ logging.critical("Arch invalid: '%s'", value)
>+ raise ValueError("Unsupported Architecture")
>+ self._arch = InfGenerator.SUPPORTED_ARCH[key]
>+
>+ @property
>+ def Date(self):
>+ return self._date.strftime("%m/%d/%Y")
>+
>+ @Date.setter
>+ def Date(self, value):
>+ if(not isinstance(value, datetime.date)):
>+ raise ValueError("Date must be a datetime.date object")
>+ self._date = value
>+
>+ def MakeInf(self, OutputInfFilePath, FirmwareBinFileName,
>Rollback=False):
>+ RollbackString = ""
>+ if(Rollback):
>+ RollbackString =
>InfGenerator.ROLLBACKTEMPLATE.format(EsrtGuid=self.EsrtGuid)
>+
>+ binfilename = os.path.basename(FirmwareBinFileName)
>+
>+ Content = InfGenerator.TEMPLATE.format(
>+ Name=self.Name,
>+ Date=self.Date,
>+ Arch=self.Arch,
>+ DriverVersion=self.VersionString,
>+ EsrtGuid=self.EsrtGuid,
>+ FirmwareBinFile=binfilename,
>+ VersionHexString=self.VersionHex,
>+ Provider=self.Provider,
>+ MfgName=self.Manufacturer,
>+ Description=self.Description,
>+ Rollback=RollbackString)
>+
>+ with open(OutputInfFilePath, "w") as f:
>+ f.write(Content)
>+
>+ return 0
>diff --git
>a/BaseTools/Source/Python/Capsule/WindowsCapsuleSupportHelper.py
>b/BaseTools/Source/Python/Capsule/WindowsCapsuleSupportHelper.py
>new file mode 100644
>index 0000000000..8abac3e31d
>--- /dev/null
>+++ b/BaseTools/Source/Python/Capsule/WindowsCapsuleSupportHelper.py
>@@ -0,0 +1,102 @@
>+##
>+# UefiBuild Plugin that supports Window Capsule files based on the
>+# Windows Firmware Update Platform spec.
>+# Creates INF, Cat, and then signs it
>+#
>+#
>+# Copyright (c) 2018, Microsoft Corporation
>+# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
>+# SPDX-License-Identifier: BSD-2-Clause-Patent
>+##
>+
>+import sys
>+import re
>+import datetime
>+import os
>+import logging
>+from CatGenerator import CatGenerator
>+from InfGenerator import InfGenerator
>+from CatGenerator import RunCmd
>+
>+def CatalogSignWithSignTool(SignToolPath, ToSignFilePath, PfxFilePath,
>PfxPass=None):
>+ # check signtool path
>+ if not os.path.exists(SignToolPath):
>+ logging.error("Path to signtool invalid. %s" % SignToolPath)
>+ return -1
>+
>+ # Adjust for spaces in the path (when calling the command).
>+ if " " in SignToolPath:
>+ SignToolPath = '"' + SignToolPath + '"'
>+
>+ OutputDir = os.path.dirname(ToSignFilePath)
>+ # Signtool docs https://docs.microsoft.com/en-
>us/dotnet/framework/tools/signtool-exe
>+ # todo: link to catalog signing documentation
>+ params = "sign /a /fd SHA256 /f " + PfxFilePath
>+ if PfxPass is not None:
>+ # add password if set
>+ params = params + ' /p ' + PfxPass
>+ params = params + ' /debug /v "' + ToSignFilePath + '" '
>+ ret = RunCmd(SignToolPath, params, workingdir=OutputDir)
>+ if(ret != 0):
>+ logging.error("Signtool failed %d" % ret)
>+ return ret
>+
>+class WindowsCapsuleSupportHelper(object):
>+ @staticmethod
>+ def _LocateLatestWindowsKits():
>+ result = None
>+
>+ # Start with a base path and use it to start locating the ideal directory.
>+ base_path = os.path.join(os.getenv("ProgramFiles(x86)"), "Windows
>Kits")
>+
>+ # Check for Win 10 kits first.
>+ base_10_path = os.path.join(base_path, "10", "bin")
>+ if os.path.isdir(base_10_path):
>+ # If you can find one of the new kit paths, use it.
>+ # Walk backwards to test the most recent kit first.
>+ for sub_path in reversed(os.listdir(base_10_path)):
>+ if sub_path.startswith("10.") and
>os.path.isdir(os.path.join(base_10_path, sub_path, "x64")):
>+ result = os.path.join(base_10_path, sub_path, "x64")
>+ break
>+
>+ # Otherwise, fall back to the legacy path.
>+ if not result and os.path.isdir(os.path.join(base_10_path, "x64")):
>+ result = os.path.join(base_10_path, "x64")
>+ # If not, fall back to Win 8.1.
>+ elif os.path.isdir(os.path.join(base_path, "8.1", "bin", "x64")):
>+ result = os.path.join(base_path, "8.1", "bin", "x64")
>+ return result
>+
>+ def RegisterHelpers(self, obj):
>+ fp = os.path.abspath(__file__)
>+ obj.Register("PackageWindowsCapsuleFiles",
>WindowsCapsuleSupportHelper.PackageWindowsCapsuleFiles, fp)
>+
>+
>+ @staticmethod
>+ def PackageWindowsCapsuleFiles(OutputFolder, ProductName,
>ProductFmpGuid, CapsuleVersion_DotString,CapsuleVersion_HexString,
>ProductFwProvider, ProductFwMfgName, ProductFwDesc, CapsuleFileName,
>PfxFile=None, PfxPass=None, Rollback=False, Arch='amd64',
>OperatingSystem_String='Win10'):
>+ logging.debug("CapsulePackage: Create Windows Capsule Files")
>+ #Make INF
>+ InfFilePath = os.path.join(OutputFolder, ProductName + ".inf")
>+ InfTool = InfGenerator(ProductName, ProductFwProvider,
>ProductFmpGuid, Arch, ProductFwDesc, CapsuleVersion_DotString,
>CapsuleVersion_HexString)
>+ InfTool.Manufacturer = ProductFwMfgName #optional
>+ ret = InfTool.MakeInf(InfFilePath, CapsuleFileName, Rollback)
>+ if(ret != 0):
>+ raise Exception("CreateWindowsInf Failed with errorcode %d" % ret)
>+ #Make CAT
>+ CatFilePath = os.path.realpath(os.path.join(OutputFolder, ProductName
>+ ".cat"))
>+ CatTool = CatGenerator(Arch, OperatingSystem_String)
>+ ret = CatTool.MakeCat(CatFilePath)
>+
>+ if(ret != 0):
>+ raise Exception("Creating Cat file Failed with errorcode %d" % ret)
>+ if(PfxFile is not None):
>+ #Find Signtool
>+ WinKitsPath =
>WindowsCapsuleSupportHelper._LocateLatestWindowsKits()
>+ SignToolPath = os.path.join(WinKitsPath, "signtool.exe")
>+ if not os.path.exists(SignToolPath):
>+ raise Exception("Can't find signtool on this machine.")
>+ #dev sign the cat file
>+ ret = CatalogSignWithSignTool(SignToolPath, CatFilePath, PfxFile,
>PfxPass)
>+ if(ret != 0):
>+ raise Exception("Signing Cat file Failed with errorcode %d" % ret)
>+ return ret
>--
>2.20.1.windows.1
>
>
>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#42324): https://edk2.groups.io/g/devel/message/42324
Mute This Topic: https://groups.io/mt/32013338/1813853
Group Owner: devel+owner at edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [edk2-devel-archive at redhat.com]
-=-=-=-=-=-=-=-=-=-=-=-
More information about the edk2-devel-archive
mailing list