BaseTools/Capsule: Add capsule dependency support

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=2412

Capsule generate tool support encode capsule dependencies through '-j'
command with a JSON file. To enable dependency feature, "Dependencies"
field for each payload in JSON file is required.
The value of "Dependencies" field is C style infix notation expression.
For example:
  "Dependencies":"72E2945A-00DA-448E-9AA7-075AD840F9D4 > 0x00000001"

The relation of Dependency Expression Opcode in UEFI2.8 chap 23.2 and
infix notation expression value is as follows:
+-----------------------------+--------------------------+
| OPCODE                      | INFIX EXPRESSION VALUE   |
+-----------------------------+--------------------------+
| 0x00 (PUSH_GUID)            | {GUID}                   |
| 0x01 (PUSH_VERSION)         | {UINT32}                 |
| 0x02 (DECLEAR_VERSION_NAME} | DECLEAR "{VERSION_NAME}" |
| 0x03 (AND)                  | &&                       |
| 0x04 (OR)                   | ||                       |
| 0x05 (NOT)                  | ~                        |
| 0x06 (TRUE)                 | TRUE                     |
| 0x07 (FALSE)                | FALSE                    |
| 0x08 (EQ)                   | ==                       |
| 0x09 (GT)                   | >                        |
| 0x0A (GTE)                  | >=                       |
| 0x0B (LT)                   | <                        |
| 0x0C (LTE)                  | <=                       |
+-----------------------------+--------------------------+

Cc: Bob Feng <bob.c.feng@intel.com>
Cc: Liming Gao <liming.gao@intel.com>

Signed-off-by: Aaron Li <aaron.li@intel.com>

Reviewed-by: Bob Feng <bob.c.feng@intel.com>

BaseTools/Source/Python/Capsule/GenerateCapsule.py

@@ -31,6 +31,7 @@ import json
 from Common.Uefi.Capsule.UefiCapsuleHeader import UefiCapsuleHeaderClass
 from Common.Uefi.Capsule.FmpCapsuleHeader  import FmpCapsuleHeaderClass
 from Common.Uefi.Capsule.FmpAuthHeader     import FmpAuthHeaderClass
+from Common.Uefi.Capsule.CapsuleDependency import CapsuleDependencyClass
 from Common.Edk2.Capsule.FmpPayloadHeader  import FmpPayloadHeaderClass
 
 #
@@ -306,6 +307,7 @@ if __name__ == '__main__':
             OpenSslOtherPublicCertFile   = ConvertJsonValue (Config, 'OpenSslOtherPublicCertFile', os.path.expandvars, Required = False, Default = None, Open = True)
             OpenSslTrustedPublicCertFile = ConvertJsonValue (Config, 'OpenSslTrustedPublicCertFile', os.path.expandvars, Required = False, Default = None, Open = True)
             SigningToolPath              = ConvertJsonValue (Config, 'SigningToolPath', os.path.expandvars, Required = False, Default = None)
+            DepexExp                     = ConvertJsonValue (Config, 'Dependencies', str, Required = False, Default = None)
 
             #
             # Read binary input file
@@ -330,7 +332,8 @@ if __name__ == '__main__':
                                             OpenSslSignerPrivateCertFile,
                                             OpenSslOtherPublicCertFile,
                                             OpenSslTrustedPublicCertFile,
-                                            SigningToolPath
+                                            SigningToolPath,
+                                            DepexExp
                                             ))
 
     def GenerateOutputJson (PayloadJsonDescriptorList):
@@ -348,7 +351,8 @@ if __name__ == '__main__':
                                   "OpenSslSignerPrivateCertFile": str(PayloadDescriptor.OpenSslSignerPrivateCertFile),
                                   "OpenSslOtherPublicCertFile": str(PayloadDescriptor.OpenSslOtherPublicCertFile),
                                   "OpenSslTrustedPublicCertFile": str(PayloadDescriptor.OpenSslTrustedPublicCertFile),
-                                  "SigningToolPath": str(PayloadDescriptor.SigningToolPath)
+                                  "SigningToolPath": str(PayloadDescriptor.SigningToolPath),
+                                  "Dependencies" : str(PayloadDescriptor.DepexExp)
                               }for PayloadDescriptor in PayloadJsonDescriptorList
                           ]
                       }
@@ -424,7 +428,8 @@ if __name__ == '__main__':
                      OpenSslSignerPrivateCertFile = None,
                      OpenSslOtherPublicCertFile   = None,
                      OpenSslTrustedPublicCertFile = None,
-                     SigningToolPath              = None
+                     SigningToolPath              = None,
+                     DepexExp                     = None
                      ):
             self.Payload                      = Payload
             self.Guid                         = Guid
@@ -438,6 +443,7 @@ if __name__ == '__main__':
             self.OpenSslOtherPublicCertFile   = OpenSslOtherPublicCertFile
             self.OpenSslTrustedPublicCertFile = OpenSslTrustedPublicCertFile
             self.SigningToolPath              = SigningToolPath
+            self.DepexExp                     = DepexExp
 
             self.UseSignTool = self.SignToolPfxFile is not None
             self.UseOpenSsl  = (self.OpenSslSignerPrivateCertFile is not None and
@@ -446,6 +452,7 @@ if __name__ == '__main__':
             self.AnyOpenSsl  = (self.OpenSslSignerPrivateCertFile is not None or
                                 self.OpenSslOtherPublicCertFile is not None or
                                 self.OpenSslTrustedPublicCertFile is not None)
+            self.UseDependency = self.DepexExp is not None
 
         def Validate(self, args):
             if self.UseSignTool and self.AnyOpenSsl:
@@ -544,7 +551,8 @@ if __name__ == '__main__':
                                             args.OpenSslSignerPrivateCertFile,
                                             args.OpenSslOtherPublicCertFile,
                                             args.OpenSslTrustedPublicCertFile,
-                                            args.SigningToolPath
+                                            args.SigningToolPath,
+                                            None
                                             ))
         for SinglePayloadDescriptor in PayloadDescriptorList:
             try:
@@ -564,6 +572,12 @@ if __name__ == '__main__':
             except:
                 print ('GenerateCapsule: error: can not encode FMP Payload Header')
                 sys.exit (1)
+            if SinglePayloadDescriptor.UseDependency:
+                CapsuleDependency.Payload = Result
+                CapsuleDependency.DepexExp = SinglePayloadDescriptor.DepexExp
+                Result = CapsuleDependency.Encode ()
+                if args.Verbose:
+                    CapsuleDependency.DumpInfo ()
             if SinglePayloadDescriptor.UseOpenSsl or SinglePayloadDescriptor.UseSignTool:
                 #
                 # Sign image with 64-bit MonotonicCount appended to end of image
@@ -657,7 +671,8 @@ if __name__ == '__main__':
                                             args.OpenSslSignerPrivateCertFile,
                                             args.OpenSslOtherPublicCertFile,
                                             args.OpenSslTrustedPublicCertFile,
-                                            args.SigningToolPath
+                                            args.SigningToolPath,
+                                            None
                                             ))
         #
         # Perform additional verification on payload descriptors
@@ -700,7 +715,8 @@ if __name__ == '__main__':
                                                                 PayloadDescriptorList[Index].OpenSslSignerPrivateCertFile,
                                                                 PayloadDescriptorList[Index].OpenSslOtherPublicCertFile,
                                                                 PayloadDescriptorList[Index].OpenSslTrustedPublicCertFile,
-                                                                PayloadDescriptorList[Index].SigningToolPath
+                                                                PayloadDescriptorList[Index].SigningToolPath,
+                                                                None
                                                                 ))
                 else:
                     PayloadDescriptorList[0].Payload = FmpCapsuleHeader.GetFmpCapsuleImageHeader (0).Payload
@@ -718,6 +734,7 @@ if __name__ == '__main__':
                                                             None,
                                                             None,
                                                             None,
+                                                            None,
                                                             None
                                                             ))
                         GUID = FmpCapsuleHeader.GetFmpCapsuleImageHeader (Index).UpdateImageTypeId
@@ -736,7 +753,8 @@ if __name__ == '__main__':
                                                             PayloadDescriptorList[Index].OpenSslSignerPrivateCertFile,
                                                             PayloadDescriptorList[Index].OpenSslOtherPublicCertFile,
                                                             PayloadDescriptorList[Index].OpenSslTrustedPublicCertFile,
-                                                            PayloadDescriptorList[Index].SigningToolPath
+                                                            PayloadDescriptorList[Index].SigningToolPath,
+                                                            None
                                                             ))
                 JsonIndex = 0
                 for SinglePayloadDescriptor in PayloadDescriptorList:
@@ -782,6 +800,23 @@ if __name__ == '__main__':
                         if args.Verbose:
                             print ('--------')
                             print ('No EFI_FIRMWARE_IMAGE_AUTHENTICATION')
+
+                    PayloadSignature = struct.unpack ('<I', SinglePayloadDescriptor.Payload[0:4])
+                    if PayloadSignature != FmpPayloadHeader.Signature:
+                        SinglePayloadDescriptor.UseDependency = True
+                        try:
+                            SinglePayloadDescriptor.Payload = CapsuleDependency.Decode (SinglePayloadDescriptor.Payload)
+                            PayloadJsonDescriptorList[JsonIndex].DepexExp = CapsuleDependency.DepexExp
+                            if args.Verbose:
+                                print ('--------')
+                                CapsuleDependency.DumpInfo ()
+                        except Exception as Msg:
+                            print ('GenerateCapsule: error: invalid dependency expression')
+                    else:
+                        if args.Verbose:
+                            print ('--------')
+                            print ('No EFI_FIRMWARE_IMAGE_DEP')
+
                     try:
                         SinglePayloadDescriptor.Payload = FmpPayloadHeader.Decode (SinglePayloadDescriptor.Payload)
                         PayloadJsonDescriptorList[JsonIndex].FwVersion = FmpPayloadHeader.FwVersion
@@ -852,6 +887,18 @@ if __name__ == '__main__':
                     except:
                         print ('--------')
                         print ('No EFI_FIRMWARE_IMAGE_AUTHENTICATION')
+
+                    PayloadSignature = struct.unpack ('<I', Result[0:4])
+                    if PayloadSignature != FmpPayloadHeader.Signature:
+                        try:
+                            Result = CapsuleDependency.Decode (Result)
+                            print ('--------')
+                            CapsuleDependency.DumpInfo ()
+                        except:
+                            print ('GenerateCapsule: error: invalid dependency expression')
+                    else:
+                        print ('--------')
+                        print ('No EFI_FIRMWARE_IMAGE_DEP')
                     try:
                         Result = FmpPayloadHeader.Decode (Result)
                         print ('--------')
@@ -973,6 +1020,7 @@ if __name__ == '__main__':
     FmpCapsuleHeader  = FmpCapsuleHeaderClass ()
     FmpAuthHeader     = FmpAuthHeaderClass ()
     FmpPayloadHeader  = FmpPayloadHeaderClass ()
+    CapsuleDependency = CapsuleDependencyClass ()
 
     EmbeddedDriverDescriptorList = []
     PayloadDescriptorList = []

BaseTools/Source/Python/Common/Uefi/Capsule/CapsuleDependency.py

@@ -0,0 +1,409 @@
+## @file
+# Module that encodes and decodes a capsule dependency.
+#
+# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+import struct
+import json
+import sys
+import uuid
+import re
+
+'''
+CapsuleDependency
+'''
+
+class OpConvert (object):
+    def __init__ (self):
+        # Opcode: (OperandSize, PackSize, PackFmt, EncodeConvert, DecodeConvert)
+        self._DepexOperations = {0x00:    (16, 16, 's', self.Str2Guid, self.Guid2Str),
+                                 0x01:    (4,  1,  'I', self.Str2Uint, self.Uint2Str),
+                                 0x02:    (1,  0,  's', self.Str2Utf8, self.Byte2Str),
+                                 }
+
+    def Str2Uint (self, Data):
+        try:
+            Value = int (Data, 16)
+        except:
+            Message = '{Data} is not a valid integer value.'.format (Data = Data)
+            raise ValueError (Message)
+        if Value < 0 or Value > 0xFFFFFFFF:
+            Message = '{Data} is not an UINT32.'.format (Data = Data)
+            raise ValueError (Message)
+        return Value
+
+    def Uint2Str (self, Data):
+        if Data < 0 or Data > 0xFFFFFFFF:
+            Message = '{Data} is not an UINT32.'.format (Data = Data)
+            raise ValueError (Message)
+        return "0x{Data:08x}".format (Data = Data)
+
+    def Str2Guid (self, Data):
+        try:
+            Guid = uuid.UUID (Data)
+        except:
+            Message = '{Data} is not a valid registry format GUID value.'.format (Data = Data)
+            raise ValueError (Message)
+        return Guid.bytes_le
+
+    def Guid2Str (self, Data):
+        try:
+            Guid = uuid.UUID (bytes_le = Data)
+        except:
+            Message = '{Data} is not a valid binary format GUID value.'.format (Data = Data)
+            raise ValueError (Message)
+        return str (Guid).upper ()
+
+    def Str2Utf8 (self, Data):
+        if isinstance (Data, str):
+            return Data.encode ('utf-8')
+        else:
+            Message = '{Data} is not a valid string.'.format (Data = Data)
+            raise ValueError (Message)
+
+    def Byte2Str (self, Data):
+        if isinstance (Data, bytes):
+            if Data[-1:] == b'\x00':
+                return str (Data[:-1], 'utf-8')
+            else:
+                return str (Data, 'utf-8')
+        else:
+            Message = '{Data} is not a valid binary string.'.format (Data = Data)
+            raise ValueError (Message)
+
+    def OpEncode (self, Opcode, Operand = None):
+        BinTemp = struct.pack ('<b', Opcode)
+        if Opcode <= 0x02 and Operand != None:
+            OperandSize, PackSize, PackFmt, EncodeConvert, DecodeConvert = self._DepexOperations[Opcode]
+            Value = EncodeConvert (Operand)
+            if Opcode == 0x02:
+                PackSize = len (Value) + 1
+            BinTemp += struct.pack ('<{PackSize}{PackFmt}'.format (PackSize = PackSize, PackFmt = PackFmt), Value)
+        return BinTemp
+
+    def OpDecode (self, Buffer):
+        Opcode = struct.unpack ('<b', Buffer[0:1])[0]
+        if Opcode <= 0x02:
+            OperandSize, PackSize, PackFmt, EncodeConvert, DecodeConvert = self._DepexOperations[Opcode]
+            if Opcode == 0x02:
+                try:
+                    PackSize = Buffer[1:].index (b'\x00') + 1
+                    OperandSize = PackSize
+                except:
+                    Message = 'CapsuleDependency: OpConvert: error: decode failed with wrong opcode/string.'
+                    raise ValueError (Message)
+            try:
+                Operand = DecodeConvert (struct.unpack ('<{PackSize}{PackFmt}'.format (PackSize = PackSize, PackFmt = PackFmt), Buffer[1:1+OperandSize])[0])
+            except:
+                Message = 'CapsuleDependency: OpConvert: error: decode failed with unpack failure.'
+                raise ValueError (Message)
+        else:
+            Operand = None
+            OperandSize = 0
+        return (Opcode, Operand, OperandSize)
+
+class CapsuleDependencyClass (object):
+    # //**************************************************************
+    # // Image Attribute - Dependency
+    # //**************************************************************
+    # typedef struct {
+    #   UINT8 Dependencies[];
+    # } EFI_FIRMWARE_IMAGE_DEP
+
+    # {expression operator : [precedence, opcode, type (1:unary/2:binocular)]}
+    _opReference = {'&&':  [2, 0x03, 2],
+                    '||':  [1, 0x04, 2],
+                    '~':   [5, 0x05, 1],
+                    '==':  [3, 0x08, 2],
+                    '>':   [4, 0x09, 2],
+                    '>=':  [4, 0x0A, 2],
+                    '<':   [4, 0x0B, 2],
+                    '<=':  [4, 0x0C, 2],
+                    }
+
+    def __init__ (self):
+        self.Payload              = b''
+        self._DepexExp            = None
+        self._DepexList           = []
+        self._DepexDump           = []
+        self.Depex                = b''
+        self._Valid               = False
+        self._DepexSize           = 0
+        self._opReferenceReverse  = {v[1] : k for k, v in self._opReference.items ()}
+        self.OpConverter          = OpConvert ()
+
+    @property
+    def DepexExp (self):
+        return self._DepexExp
+
+    @DepexExp.setter
+    def DepexExp (self, DepexExp = ''):
+        if isinstance (DepexExp, str):
+            DepexExp = re.sub (r'\n',r' ',DepexExp)
+            DepexExp = re.sub (r'\(',r' ( ',DepexExp)
+            DepexExp = re.sub (r'\)',r' ) ',DepexExp)
+            DepexExp = re.sub (r'~',r' ~ ',DepexExp)
+            self._DepexList = re.findall(r"[^\s\"\']+|\"[^\"]*\"|\'[^\']*\'",DepexExp)
+            self._DepexExp  = " ".join(self._DepexList)
+
+        else:
+            Msg = 'Input Depex Expression is not valid string.'
+            raise ValueError (Msg)
+
+    def IsValidOperator (self, op):
+        return op in self._opReference.keys ()
+
+    def IsValidUnaryOperator (self, op):
+        return op in self._opReference.keys () and self._opReference[op][2] == 1
+
+    def IsValidBinocularOperator (self, op):
+        return op in self._opReference.keys () and self._opReference[op][2] == 2
+
+    def IsValidGuid (self, operand):
+        try:
+            uuid.UUID (operand)
+        except:
+            return False
+        return True
+
+    def IsValidVersion (self, operand):
+        try:
+            Value = int (operand, 16)
+            if Value < 0 or Value > 0xFFFFFFFF:
+                return False
+        except:
+            return False
+        return True
+
+    def IsValidBoolean (self, operand):
+        try:
+            return operand.upper () in ['TRUE', 'FALSE']
+        except:
+            return False
+
+    def IsValidOperand (self, operand):
+        return self.IsValidVersion (operand) or self.IsValidGuid (operand) or self.IsValidBoolean (operand)
+
+    def IsValidString (self, operand):
+        return operand[0] == "\"" and operand[-1] == "\"" and len(operand) >= 2
+
+    # Check if priority of current operater is greater than pervious op
+    def PriorityNotGreater (self, prevOp, currOp):
+        return self._opReference[currOp][0] <= self._opReference[prevOp][0]
+
+    def ValidateDepex (self):
+        OpList = self._DepexList
+
+        i = 0
+        while i < len (OpList):
+            Op = OpList[i]
+
+            if Op == 'DECLARE':
+                i += 1
+                if i >= len (OpList):
+                    Msg = 'No more Operand after {Op}.'.format (Op = OpList[i-1])
+                    raise IndexError (Msg)
+                # Check valid string
+                if not self.IsValidString(OpList[i]):
+                    Msg = '{Operand} after {Op} is not a valid expression input.'.format (Operand = OpList[i], Op = OpList[i-1])
+                    raise ValueError (Msg)
+
+            elif Op == '(':
+                # Expression cannot end with (
+                if i == len (OpList) - 1:
+                    Msg = 'Expression cannot end with \'(\''
+                    raise ValueError (Msg)
+                # The previous op after '(' cannot be a binocular operator
+                if self.IsValidBinocularOperator (OpList[i+1]) :
+                    Msg = '{Op} after \'(\' is not a valid expression input.'.format (Op = OpList[i+1])
+                    raise ValueError (Msg)
+
+            elif Op == ')':
+                # Expression cannot start with )
+                if i == 0:
+                    Msg = 'Expression cannot start with \')\''
+                    raise ValueError (Msg)
+                # The previous op before ')' cannot be an operator
+                if self.IsValidOperator (OpList[i-1]):
+                    Msg = '{Op} before \')\' is not a valid expression input.'.format (Op = OpList[i-1])
+                    raise ValueError (Msg)
+                # The next op after ')' cannot be operand or unary operator
+                if (i + 1) < len (OpList) and (self.IsValidOperand (OpList[i+1]) or self.IsValidUnaryOperator (OpList[i+1])):
+                    Msg = '{Op} after \')\' is not a valid expression input.'.format (Op = OpList[i+1])
+                    raise ValueError (Msg)
+
+            elif self.IsValidOperand (Op):
+                # The next expression of operand cannot be operand or unary operator
+                if (i + 1) < len (OpList) and (self.IsValidOperand (OpList[i+1]) or self.IsValidUnaryOperator (OpList[i+1])):
+                    Msg = '{Op} after {PrevOp} is not a valid expression input.'.format (Op = OpList[i+1], PrevOp = Op)
+                    raise ValueError (Msg)
+
+            elif self.IsValidOperator (Op):
+                # The next op of operator cannot binocular operator
+                if (i + 1) < len (OpList) and self.IsValidBinocularOperator (OpList[i+1]):
+                    Msg = '{Op} after {PrevOp} is not a valid expression input.'.format (Op = OpList[i+1], PrevOp = Op)
+                    raise ValueError (Msg)
+                # The first op can not be binocular operator
+                if i == 0 and self.IsValidBinocularOperator (Op):
+                    Msg = 'Expression cannot start with an operator {Op}.'.format (Op = Op)
+                    raise ValueError (Msg)
+                # The last op can not be operator
+                if i == len (OpList) - 1:
+                    Msg = 'Expression cannot ended with an operator {Op}.'.format (Op = Op)
+                    raise ValueError (Msg)
+                # The next op of unary operator cannot be guid / version
+                if self.IsValidUnaryOperator (Op) and (self.IsValidGuid (OpList[i+1]) or self.IsValidVersion (OpList[i+1])):
+                    Msg = '{Op} after {PrevOp} is not a valid expression input.'.format (Op = OpList[i+1], PrevOp = Op)
+                    raise ValueError (Msg)
+
+            else:
+                Msg = '{Op} is not a valid expression input.'.format (Op = Op)
+                raise ValueError (Msg)
+            i += 1
+
+    def Encode (self):
+        # initialize
+        self.Depex = b''
+        self._DepexDump = []
+        OperandStack = []
+        OpeartorStack = []
+        OpList = self._DepexList
+
+        self.ValidateDepex ()
+
+        # convert
+        i = 0
+        while i < len (OpList):
+            Op = OpList[i]
+            if Op == 'DECLARE':
+                # This declare next expression value is a VERSION_STRING
+                i += 1
+                self.Depex += self.OpConverter.OpEncode (0x02, OpList[i][1:-1])
+
+            elif Op == '(':
+                OpeartorStack.append (Op)
+
+            elif Op == ')':
+                while (OpeartorStack and OpeartorStack[-1] != '('):
+                    Operator = OpeartorStack.pop ()
+                    self.Depex += self.OpConverter.OpEncode (self._opReference[Operator][1])
+                try:
+                    OpeartorStack.pop () # pop out '('
+                except:
+                    Msg = 'Pop out \'(\' failed, too many \')\''
+                    raise ValueError (Msg)
+
+            elif self.IsValidGuid (Op):
+                if not OperandStack:
+                    OperandStack.append (self.OpConverter.OpEncode (0x00, Op))
+                else:
+                    # accroding to uefi spec 2.8, the guid/version operands is a reversed order in firmware comparison.
+                    self.Depex += self.OpConverter.OpEncode (0x00, Op)
+                    self.Depex += OperandStack.pop ()
+
+            elif self.IsValidVersion (Op):
+                if not OperandStack:
+                    OperandStack.append (self.OpConverter.OpEncode (0x01, Op))
+                else:
+                    # accroding to uefi spec 2.8, the guid/version operands is a reversed order in firmware comparison.
+                    self.Depex += self.OpConverter.OpEncode (0x01, Op)
+                    self.Depex += OperandStack.pop ()
+
+            elif self.IsValidBoolean (Op):
+                if Op.upper () == 'FALSE':
+                    self.Depex += self.OpConverter.OpEncode (0x07)
+                elif Op.upper () == 'TRUE':
+                    self.Depex += self.OpConverter.OpEncode (0x06)
+
+            elif self.IsValidOperator (Op):
+                while (OpeartorStack and OpeartorStack[-1] != '(' and self.PriorityNotGreater (OpeartorStack[-1], Op)):
+                    Operator = OpeartorStack.pop ()
+                    self.Depex += self.OpConverter.OpEncode (self._opReference[Operator][1])
+                OpeartorStack.append (Op)
+
+            i += 1
+
+        while OpeartorStack:
+            Operator = OpeartorStack.pop ()
+            if Operator == '(':
+                Msg = 'Too many \'(\'.'
+                raise ValueError (Msg)
+            self.Depex += self.OpConverter.OpEncode (self._opReference[Operator][1])
+        self.Depex += self.OpConverter.OpEncode (0x0D)
+
+        self._Valid = True
+        self._DepexSize = len (self.Depex)
+        return self.Depex + self.Payload
+
+    def Decode (self, Buffer):
+        # initialize
+        self.Depex = Buffer
+        OperandStack = []
+        DepexLen = 0
+
+        while True:
+            Opcode, Operand, OperandSize = self.OpConverter.OpDecode (Buffer[DepexLen:])
+            DepexLen += OperandSize + 1
+
+            if Opcode == 0x0D:
+                break
+
+            elif Opcode == 0x02:
+                if not OperandStack:
+                    OperandStack.append ('DECLARE \"{String}\"'.format (String = Operand))
+                else:
+                    PrevOperand = OperandStack.pop ()
+                    OperandStack.append ('{Operand} DECLARE \"{String}\"'.format (Operand = PrevOperand, String = Operand))
+
+            elif Opcode in [0x00, 0x01]:
+                OperandStack.append (Operand)
+
+            elif Opcode == 0x06:
+                OperandStack.append ('TRUE')
+
+            elif Opcode == 0x07:
+                OperandStack.append ('FALSE')
+
+            elif self.IsValidOperator (self._opReferenceReverse[Opcode]):
+                Operator = self._opReferenceReverse[Opcode]
+                if self.IsValidUnaryOperator (self._opReferenceReverse[Opcode]) and len (OperandStack) >= 1:
+                    Oprand = OperandStack.pop ()
+                    OperandStack.append (' ( {Operator} {Oprand} )'.format (Operator = Operator, Oprand = Oprand))
+                elif self.IsValidBinocularOperator (self._opReferenceReverse[Opcode]) and len (OperandStack) >= 2:
+                    Oprand1 = OperandStack.pop ()
+                    Oprand2 = OperandStack.pop ()
+                    OperandStack.append (' ( {Oprand1} {Operator} {Oprand2} )'.format (Operator = Operator, Oprand1 = Oprand1, Oprand2 = Oprand2))
+                else:
+                    Msg = 'No enough Operands for {Opcode:02X}.'.format (Opcode = Opcode)
+                    raise ValueError (Msg)
+
+            else:
+                Msg = '{Opcode:02X} is not a valid OpCode.'.format (Opcode = Opcode)
+                raise ValueError (Msg)
+
+        self.DepexExp = OperandStack[0].strip (' ')
+        self.Payload = Buffer[DepexLen:]
+        self._Valid = True
+        self._DepexSize = DepexLen
+        return self.Payload
+
+
+    def DumpInfo (self):
+        DepexLen = 0
+        Opcode = None
+        Buffer = self.Depex
+
+        if self._Valid == True:
+            print ('EFI_FIRMWARE_IMAGE_DEP.Dependencies = {')
+            while Opcode != 0x0D:
+                Opcode, Operand, OperandSize = self.OpConverter.OpDecode (Buffer[DepexLen:])
+                DepexLen += OperandSize + 1
+                if Operand:
+                    print ('    {Opcode:02X}, {Operand},'.format (Opcode = Opcode, Operand = Operand))
+                else:
+                    print ('    {Opcode:02X},'.format (Opcode = Opcode))
+            print ('}')
+
+            print ('sizeof (EFI_FIRMWARE_IMAGE_DEP.Dependencies)    = {Size:08X}'.format (Size = self._DepexSize))
+            print ('sizeof (Payload)                                = {Size:08X}'.format (Size = len (self.Payload)))