DER_Img4Manifest.c

Go to the documentation of this file.

 
#include "libDER/libDER.h"
#include "libDER/asn1Types.h"
#include "libDER/DER_CertCrl.h"
#include "libDER/DER_Decode.h"
#include "libDER/DER_Keys.h"
#include "libDER/oids.h"
 
#include "libDERImg4.h"
#include "DER_Img4Manifest.h"
#include "Img4oids.h"
 
typedef struct {
  DERItem          certItem;
  DERSignedCertCrl certCtrl;
  DERTBSCert       tbsCert;
  DERItem          pubKeyItem;
  DERItem          manCertRoleItem;
} Image4CertificateInfo;
 
enum {
  Img4ManifestPropSetTypeManp = 0,
  Img4ManifestPropSetTypeObjp = 1
};
 
bool
DERItemCompare (
  const DERItem  *Item1,
  const DERItem  *Item2
  )
{
  assert (Item1 != NULL);
  assert (Item2 != NULL);
 
  if (Item1->length != Item2->length) {
    return false;
  }
 
  return DERMemcmp (Item1->data, Item2->data, Item1->length) == 0;
}
 
bool
DERItemNull (
  const DERItem  *Item
  )
{
  assert (Item != NULL);
 
  if (Item->length == 2 && Item->data[0] == ASN1_NULL && Item->data[1] == 0) {
    return true;
  } else if (Item->length == 0) {
    return true;
  }
 
  return false;
}
 
DERReturn
DERImg4ParseInteger64 (
  const DERItem  *Contents,
  uint64_t       *Result
  )
{
  DERSize  Index;
  DERSize  Length;
  uint64_t Value;
 
  assert (Contents != NULL);
  assert (Result   != NULL);
 
  Length = Contents->length;
  if (Length == 0 || (Contents->data[0] & 0x80U) != 0) {
    return DR_DecodeError;
  }
 
  Value = Contents->data[0];
  if (Length == 1) {
    *Result = Value;
    return DR_Success;
  }
  //
  // It is not perfectly clear why the different sizes are allowed in this way.
  // The original libDER only supports 32-bit integers and I assume bit
  // strings, which have their first byte signal the number of unused bits,
  // might have been or are used to implement 64-bit integers. In this case,
  // the number of unused bits must be 0 and this byte is discarded.
  //
  if (Length > 9 || (Value != 0 && Length > 8)) {
    return DR_BufOverflow;
  }
 
  if (Value == 0 && (Contents->data[1] & 0x80U) == 0) {
    return DR_DecodeError;
  }
 
  for (Index = 1; Index < Length; ++Index) {
    Value <<= 8U;
    Value += Contents->data[Index];
  }
 
  *Result = Value;
  return DR_Success;
}
 
DERReturn
DERImg4ParseInteger32 (
  const DERItem   *Contents,
  uint32_t        *Result
  )
{
  DERReturn DerResult;
  uint64_t  Result64;
 
  assert (Contents != NULL);
  assert (Result != NULL);
 
  DerResult = DERImg4ParseInteger64 (Contents, &Result64);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if ((Result64 & 0xFFFFFFFF80000000U) != 0) {
    return DR_BufOverflow;
  }
 
  *Result = (uint32_t)Result64;
  return DR_Success;
}
 
DERReturn
DERVerifySignature (
  const DERItem  *PubKeyItem,
  const DERItem  *SigItem,
  const DERItem  *DataItem,
  const DERItem  *algoOid
  )
{
  bool              Result;
  DERReturn         DerResult;
 
  DERRSAPubKeyPKCS1 PkPkcs1;
 
  DERItem           ModulusItem;
  DERByte           NumUnusedBits;
 
  uint32_t          Exponent;
 
  assert (PubKeyItem != NULL);
  assert (SigItem    != NULL);
  assert (DataItem   != NULL);
  assert (algoOid    != NULL);
 
  DerResult = DERParseSequence (
                PubKeyItem,
                DERNumRSAPubKeyPKCS1ItemSpecs,
                DERRSAPubKeyPKCS1ItemSpecs,
                &PkPkcs1,
                sizeof (PkPkcs1)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERParseBitString (
                &PkPkcs1.modulus,
                &ModulusItem,
                &NumUnusedBits
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (NumUnusedBits != 0) {
    return DR_DecodeError;
  }
 
  DerResult = DERImg4ParseInteger32 (&PkPkcs1.pubExponent, &Exponent);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  Result = DERImg4VerifySignature (
             ModulusItem.data,
             ModulusItem.length,
             Exponent,
             SigItem->data,
             SigItem->length,
             DataItem->data,
             DataItem->length,
             algoOid
             );
  if (!Result) {
    return (DERReturn)DR_SecurityError;
  }
 
  return DR_Success;
}
 
static
DERReturn
DERImg4ManifestVerifyMagic (
  const DERItem  *ManItem
  )
{
  DERReturn DerResult;
  uint32_t  ItemTag;
 
  assert (ManItem != NULL);
 
  if (ManItem->length != sizeof (ItemTag)) {
    return DR_DecodeError;
  }
 
  DerResult = DERImg4ParseInteger32 (ManItem, &ItemTag);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (ItemTag != DER_IMG4_TAG_MAN_MAGIC) {
    return DR_UnexpectedTag;
  }
 
  return DR_Success;
}
 
static
DERReturn
DERImg4ManifestCollectCertInfo (
  Image4CertificateInfo  *CertInfo
  )
{
  DERReturn         DerResult;
 
  DERTag            CertTbsTag;
  DERSubjPubKeyInfo CertPubKeyInfo;
  DERAlgorithmId    CertSigAlgoId;
 
  DERSequence       CertTbsSeq;
  DERDecodedInfo    CertTbsSeqInfo;
  DERDecodedInfo    CertExtValueInfo;
  DERExtension      TbsCertExt;
 
  DERByte           NumUnusedBits;
 
  assert (CertInfo != NULL);
 
  DerResult = DERParseSequence (
                &CertInfo->certItem,
                DERNumSignedCertCrlItemSpecs,
                DERSignedCertCrlItemSpecs,
                &CertInfo->certCtrl,
                sizeof (CertInfo->certCtrl)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERParseSequence (
                &CertInfo->certCtrl.tbs,
                DERNumTBSCertItemSpecs,
                DERTBSCertItemSpecs,
                &CertInfo->tbsCert,
                sizeof (CertInfo->tbsCert)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERParseSequenceContent (
                &CertInfo->tbsCert.subjectPubKey,
                DERNumSubjPubKeyInfoItemSpecs,
                DERSubjPubKeyInfoItemSpecs,
                &CertPubKeyInfo,
                sizeof (CertPubKeyInfo)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERParseSequenceContent (
                &CertPubKeyInfo.algId,
                DERNumAlgorithmIdItemSpecs,
                DERAlgorithmIdItemSpecs,
                &CertSigAlgoId,
                sizeof (CertSigAlgoId)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (!DEROidCompare (&CertSigAlgoId.oid, &oidRsa)
   || !DERItemNull (&CertSigAlgoId.params)) {
    return (DERReturn)DR_SecurityError;
  }
 
  DerResult = DERParseBitString (
                &CertPubKeyInfo.pubKey,
                &CertInfo->pubKeyItem,
                &NumUnusedBits
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (NumUnusedBits != 0) {
    return DR_DecodeError;
  }
  //
  // The Manifest Certificate Role is only required to be declared by the last
  // certificate in the Manifest Certificate Chain.
  //
  CertInfo->manCertRoleItem.data   = NULL;
  CertInfo->manCertRoleItem.length = 0;
  if (CertInfo->tbsCert.extensions.length != 0) {
    DerResult = DERDecodeSeqInit (
                  &CertInfo->tbsCert.extensions,
                  &CertTbsTag,
                  &CertTbsSeq
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    if (CertTbsTag != ASN1_CONSTR_SEQUENCE) {
      return DR_UnexpectedTag;
    }
 
    while (DERDecodeSeqNext (&CertTbsSeq, &CertTbsSeqInfo) == DR_Success) {
      if (CertTbsSeqInfo.tag != ASN1_CONSTR_SEQUENCE) {
        return DR_UnexpectedTag;
      }
 
      DerResult = DERParseSequenceContent (
                    &CertTbsSeqInfo.content,
                    DERNumExtensionItemSpecs,
                    DERExtensionItemSpecs,
                    &TbsCertExt,
                    sizeof (TbsCertExt)
                    );
      if (DerResult != DR_Success) {
        return DerResult;
      }
 
      if (DEROidCompare (&TbsCertExt.extnID, &oidAppleImg4ManifestCertSpec)) {
        DerResult = DERDecodeItem (&TbsCertExt.extnValue, &CertExtValueInfo);
        if (DerResult != DR_Success) {
          return DerResult;
        }
 
        if (CertExtValueInfo.tag != ASN1_CONSTR_SET) {
          return DR_UnexpectedTag;
        }
 
        CertInfo->manCertRoleItem.data   = TbsCertExt.extnValue.data;
        CertInfo->manCertRoleItem.length = TbsCertExt.extnValue.length;
        break;
      }
    }
  }
 
  return DR_Success;
}
 
DERReturn
DERImg4ManifestVerifyCertIssuer (
  const Image4CertificateInfo  *ChildCertInfo,
  const Image4CertificateInfo  *ParentCertInfo
  )
{
  bool           Result;
  DERReturn      DerResult;
 
  DERAlgorithmId CertSigAlgoId;
  DERItem        CertSigItem;
 
  DERByte        NumUnusedBits;
 
  assert (ChildCertInfo != NULL);
  assert (ParentCertInfo != NULL);
 
  Result = DERItemCompare (
             &ChildCertInfo->tbsCert.issuer,
             &ParentCertInfo->tbsCert.subject
             );
  if (!Result) {
    return (DERReturn)DR_SecurityError;
  }
 
  DerResult = DERParseSequenceContent (
                &ChildCertInfo->certCtrl.sigAlg,
                DERNumAlgorithmIdItemSpecs,
                DERAlgorithmIdItemSpecs,
                &CertSigAlgoId,
                sizeof (CertSigAlgoId)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (!DERItemNull (&CertSigAlgoId.params)) {
    return (DERReturn)DR_SecurityError;
  }
 
  DerResult = DERParseBitString (
                &ChildCertInfo->certCtrl.sig,
                &CertSigItem,
                &NumUnusedBits
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (NumUnusedBits != 0) {
    return DR_DecodeError;
  }
 
  DerResult = DERVerifySignature (
                &ParentCertInfo->pubKeyItem,
                &CertSigItem,
                &ChildCertInfo->certCtrl.tbs,
                &CertSigAlgoId.oid
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  return DR_Success;
}
 
DERReturn
DERImg4ManifestVerifySignature (
  DERItem                  *ManCertRoleItem,
  const DERImg4Manifest    *Manifest
  )
{
  DERReturn             DerResult;
 
  Image4CertificateInfo ParentCertInfo;
  Image4CertificateInfo CurCertInfo;
 
  DERItem               CertItem;
  DERDecodedInfo        CertInfo;
  DERByte               *NextCert;
  DERByte               *CertWalker;
  DERSize               LeftCertSize;
  DERSize               CertSize;
  DERSize               Index;
  
  DERAlgorithmId        CertSigAlgoId;
 
  assert (ManCertRoleItem != NULL);
  assert (Manifest != NULL);
  //
  // Verify the Manifest certification chain.
  //
  if (Manifest->certificates.length == 0) {
    return DR_DecodeError;
  }
  //
  // These pointers must be provided by the platform integrator, either by an
  // external variable declaration or by a macro.
  //
  assert (DERImg4RootCertificate != NULL);
  assert (DERImg4RootCertificateSize != NULL);
 
  CurCertInfo.certItem.data   = (DERByte *)DERImg4RootCertificate;
  CurCertInfo.certItem.length = *DERImg4RootCertificateSize;
  DerResult = DERImg4ManifestCollectCertInfo (&CurCertInfo);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  CertWalker = Manifest->certificates.data;
  for (
    Index = 1, LeftCertSize = Manifest->certificates.length;
    Index < DER_IMG4_MAN_CERT_CHAIN_MAX && LeftCertSize > 0;
    ++Index, LeftCertSize -= CertSize
    ) {
    CopyMem (&ParentCertInfo, &CurCertInfo, sizeof (ParentCertInfo));
 
    CertItem.data   = CertWalker;
    CertItem.length = LeftCertSize;
    DerResult = DERDecodeItem (&CertItem, &CertInfo);
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    NextCert = &CertInfo.content.data[CertInfo.content.length];
    CertSize = NextCert - CertWalker;
    //
    // This is a guarantee libDER is supposed to make.
    //
    assert (CertSize <= LeftCertSize);
    if (CertSize > DER_IMG4_MAX_CERT_SIZE) {
      return DR_DecodeError;
    }
 
    CurCertInfo.certItem.data   = CertWalker;
    CurCertInfo.certItem.length = CertSize;
 
    CertWalker = NextCert;
 
    DerResult = DERImg4ManifestCollectCertInfo (&CurCertInfo);
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    DerResult = DERImg4ManifestVerifyCertIssuer (
                  &CurCertInfo,
                  &ParentCertInfo
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
  }
 
  if (LeftCertSize != 0) {
    return DR_DecodeError;
  }
 
  if (CurCertInfo.manCertRoleItem.data == NULL
   || CurCertInfo.manCertRoleItem.length == 0) {
    return DR_DecodeError;
  }
  //
  // Verify the Manifest body signature.
  //
  DerResult = DERParseSequenceContent (
                &CurCertInfo.tbsCert.tbsSigAlg,
                DERNumAlgorithmIdItemSpecs,
                DERAlgorithmIdItemSpecs,
                &CertSigAlgoId,
                sizeof (CertSigAlgoId)
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (!DERItemNull (&CertSigAlgoId.params)) {
    return (DERReturn)DR_SecurityError;
  }
 
  DerResult = DERVerifySignature (
                &CurCertInfo.pubKeyItem,
                &Manifest->signature,
                &Manifest->body,
                &CertSigAlgoId.oid
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  ManCertRoleItem->data   = CurCertInfo.manCertRoleItem.data;
  ManCertRoleItem->length = CurCertInfo.manCertRoleItem.length;
  return DR_Success;
}
 
DERReturn
DERImg4FindPropertyItem (
  const DERItem  *PropSetItem,
  DERTag         PropName,
  DERItem        *PropItem
  )
{
  DERReturn      DerResult;
 
  DERSequence    PropSetSeq;
  DERDecodedInfo PropInfo;
 
  assert (PropSetItem != NULL);
  assert (PropItem != NULL);
 
  DerResult = DERDecodeSeqContentInit (PropSetItem, &PropSetSeq);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  while ((DerResult = DERDecodeSeqNext (&PropSetSeq, &PropInfo)) == DR_Success) {
    if (PropInfo.tag == PropName) {
      PropItem->length = PropInfo.content.length;
      PropItem->data   = PropInfo.content.data;
      return DR_Success;
    }
  }
 
  return DerResult;
}
 
DERReturn
DERImg4FindDecodeProperty (
  const DERItem    *PropSetItem,
  DERTag           PropName,
  DERTag           PropValueTag,
  DERImg4Property  *Property
  )
{
  STATIC CONST DERItemSpec PropertyItemSpecTpl[] = DER_IMG4_PROPERTY_SPEC_INIT;
 
  DERReturn   DerResult;
  DERItem     PropItem;
  uint32_t    CurPropTag;
  DERItemSpec PropertyItemSpec[ARRAY_SIZE (PropertyItemSpecTpl)];
 
  CopyMem (PropertyItemSpec, PropertyItemSpecTpl, sizeof (PropertyItemSpecTpl));
 
  PropertyItemSpec[1].tag = PropValueTag;
 
  assert (PropSetItem != NULL);
  assert (Property != NULL);
 
  DerResult = DERImg4FindPropertyItem (
                PropSetItem,
                PropName,
                &PropItem
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERParseSequence (
                &PropItem,
                ARRAY_SIZE (PropertyItemSpec),
                PropertyItemSpec,
                Property,
                0
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4ParseInteger32 (&Property->nameItem, &CurPropTag);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (DER_IMG4_ENCODE_PROPERTY_NAME (CurPropTag) != PropName) {
    return DR_UnexpectedTag;
  }
 
  Property->nameTag  = PropName;
  Property->valueTag = PropValueTag;
  return DR_Success;
}
 
DERReturn
DERImg4DecodeProperty (
  const DERItem    *PropItem,
  DERTag           PropName,
  DERImg4Property  *Property
  )
{
  DERReturn      DerResult;
 
  DERTag         PropTag;
  DERSequence    PropSeq;
 
  DERDecodedInfo PropNameInfo;
  uint32_t       PropNameTag;
 
  DERDecodedInfo PropValueInfo;
  DERDecodedInfo PropTailInfo;
 
  assert (PropItem != NULL);
  assert (Property != NULL);
 
  DerResult = DERDecodeSeqInit (PropItem, &PropTag, &PropSeq);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (PropTag != ASN1_CONSTR_SEQUENCE) {
    return DR_UnexpectedTag;
  }
 
  DerResult = DERDecodeSeqNext (&PropSeq, &PropNameInfo);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (PropNameInfo.tag != ASN1_IA5_STRING) {
    return DR_UnexpectedTag;
  }
  
  DerResult = DERImg4ParseInteger32 (&PropNameInfo.content, &PropNameTag);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (DER_IMG4_ENCODE_PROPERTY_NAME (PropNameTag) != PropName) {
    return DR_UnexpectedTag;
  }
 
  DerResult = DERDecodeSeqNext (&PropSeq, &PropValueInfo);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERDecodeSeqNext (&PropSeq, &PropTailInfo);
  if (DerResult != DR_EndOfSequence) {
    return DR_DecodeError;
  }
  
  Property->nameTag         = PropName;
  Property->nameItem.data   = PropNameInfo.content.data;
  Property->nameItem.length = PropNameInfo.content.length;
 
  Property->valueTag         = PropValueInfo.tag;
  Property->valueItem.data   = PropValueInfo.content.data;
  Property->valueItem.length = PropValueInfo.content.length;
  return DR_Success;
}
 
DERReturn
DERImg4ManifestDecodePropertyBoolean (
  const DERItem  *PropItem,
  uint32_t       PropName,
  bool           *Value
  )
{
  DERReturn       DerResult;
  DERImg4Property Property;
 
  assert (PropItem != NULL);
  assert (Value != NULL);
 
  DerResult = DERImg4DecodeProperty (
                PropItem,
                DER_IMG4_ENCODE_PROPERTY_NAME (PropName),
                &Property
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (Property.valueTag != ASN1_BOOLEAN) {
    return DR_UnexpectedTag;
  }
 
  if (Property.valueItem.length != 1
   || (*Property.valueItem.data != 0 && *Property.valueItem.data != 0xFF)) {
    return DR_DecodeError;
  }
 
  *Value = *Property.valueItem.data != 0;
  return DR_Success;
}
 
DERReturn
DERImg4DecodePropertyInteger32 (
  const DERItem  *PropItem,
  uint32_t       PropName,
  uint32_t       *Value
  )
{
  DERReturn       DerResult;
  DERImg4Property Property;
 
  assert (PropItem != NULL);
  assert (Value != NULL);
 
  DerResult = DERImg4DecodeProperty (
                PropItem,
                DER_IMG4_ENCODE_PROPERTY_NAME (PropName),
                &Property
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (Property.valueTag != ASN1_INTEGER) {
    return DR_UnexpectedTag;
  }
  
  return DERImg4ParseInteger32 (&Property.valueItem, Value);
}
 
DERReturn
DERImg4DecodePropertyInteger64 (
  const DERItem  *PropItem,
  uint32_t       PropName,
  uint64_t       *Value
  )
{
  DERReturn       DerResult;
  DERImg4Property Property;
 
  assert (PropItem != NULL);
  assert (Value != NULL);
 
  DerResult = DERImg4DecodeProperty (
                PropItem,
                DER_IMG4_ENCODE_PROPERTY_NAME (PropName),
                &Property
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (Property.valueTag != ASN1_INTEGER) {
    return DR_UnexpectedTag;
  }
  
  return DERImg4ParseInteger64 (&Property.valueItem, Value);
}
 
DERReturn
DERImg4ValidateCertificateRole (
  const DERItem  *ManPropSetItem,
  const DERItem  *ObjPropSetItem,
  const DERItem  *ManBodyCertItem
  )
{
  DERReturn       DerResult;
  DERReturn       LoopDerResult;
  DERReturn       LoopDerResult2;
 
  DERTag          ManBodyCertTag;
  DERSequence     ManBodyCertSet;
 
  DERDecodedInfo  CertPropSetInfo;
  DERImg4Property CertPropSet;
  DERSequence     CertPropSetSeq;
 
  DERDecodedInfo  CertPropInfo;
  DERImg4Property CurCertProp;
 
  DERItem         BodyPropSetItem;
  DERItem         BodyPropItem;
 
  assert (ManPropSetItem != NULL);
  assert (ObjPropSetItem != NULL);
  assert (ManBodyCertItem != NULL);
 
  DerResult = DERDecodeSeqInit (
                ManBodyCertItem,
                &ManBodyCertTag,
                &ManBodyCertSet
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (ManBodyCertTag != ASN1_CONSTR_SET) {
    return DR_UnexpectedTag;
  }
 
  while ((LoopDerResult = DERDecodeSeqNext (&ManBodyCertSet, &CertPropSetInfo)) == DR_Success) {
    if (CertPropSetInfo.tag == DER_IMG4_ENCODE_PROPERTY_NAME (DER_IMG4_TAG_OBJ_PROPS)) {
      BodyPropSetItem.data   = ObjPropSetItem->data;
      BodyPropSetItem.length = ObjPropSetItem->length;
    } else if (CertPropSetInfo.tag == DER_IMG4_ENCODE_PROPERTY_NAME (DER_IMG4_TAG_MAN_PROPS)) {
      BodyPropSetItem.data   = ManPropSetItem->data;
      BodyPropSetItem.length = ManPropSetItem->length;
    } else {
      return DR_UnexpectedTag;
    }
 
    DerResult = DERImg4DecodeProperty (
                  &CertPropSetInfo.content,
                  CertPropSetInfo.tag,
                  &CertPropSet
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    if (CertPropSet.valueTag != ASN1_CONSTR_SET) {
      return DR_UnexpectedTag;
    }
 
    DerResult = DERDecodeSeqContentInit (
                  &CertPropSet.valueItem,
                  &CertPropSetSeq
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    while ((LoopDerResult2 = DERDecodeSeqNext (&CertPropSetSeq, &CertPropInfo)) == DR_Success) {
      DerResult = DERImg4DecodeProperty (
                    &CertPropInfo.content,
                    CertPropInfo.tag,
                    &CurCertProp
                    );
      if (DerResult != DR_Success) {
        return DerResult;
      }
 
      DerResult = DERImg4FindPropertyItem (
                    &BodyPropSetItem,
                    CertPropInfo.tag,
                    &BodyPropItem
                    );
      if (CurCertProp.valueTag == ASN1_BOOLEAN
       || CurCertProp.valueTag == ASN1_INTEGER
       || CurCertProp.valueTag == ASN1_OCTET_STRING) {
        //
        // The specified key must be present with the exact role value.
        //
        if (DerResult != DR_Success) {
          return DerResult;
        }
 
        if (!DERItemCompare (&CertPropInfo.content, &BodyPropItem)) {
          return (DERReturn)DR_SecurityError;
        }
      } else if (CurCertProp.valueTag == (ASN1_CONSTRUCTED | ASN1_CONTEXT_SPECIFIC | 0)) {
        //
        // The specified key must be present with an arbitrary value.
        //
        if (DerResult != DR_Success) {
          return DerResult;
        }
      } else if (CurCertProp.valueTag == (ASN1_CONSTRUCTED | ASN1_CONTEXT_SPECIFIC | 1)) {
        //
        // The specified key must not be present.
        //
        if (DerResult != DR_EndOfSequence) {
          return DR_UnexpectedTag;
        }
      } else {
        //
        // An unexpected tag has been encountered.
        //
        return DR_UnexpectedTag;
      }
    }
 
    if (LoopDerResult2 != DR_EndOfSequence) {
      return DR_DecodeError;
    }
  }
 
  if (LoopDerResult != DR_EndOfSequence) {
    return LoopDerResult;
  }
 
  return DR_Success;
}
 
DERReturn
DERImg4ManifestDecodeProperty (
  const DERItem        *PropItem,
  uint32_t             PropName,
  DERImg4ManifestInfo  *ManInfo,
  uint32_t             PropSetType
  )
{
  DERReturn       DerResult;
  DERImg4Property Property;
  uint64_t        Ecid;
 
  assert (PropItem != NULL);
  assert (ManInfo != NULL);
 
  if (PropSetType == Img4ManifestPropSetTypeObjp) {
    switch (PropName) {
      case DER_IMG4_TAG_OBJ_EPRO:
      {
        ManInfo->hasEffectiveProductionStatus = true;
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.effectiveProductionStatus
                 );
      }
 
      case DER_IMG4_TAG_OBJ_ESEC:
      {
        ManInfo->hasEffectiveSecurityMode = true;
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.effectiveSecurityMode
                 );
      }
 
      case DER_IMG4_TAG_OBJ_DGST:
      {
        DerResult = DERImg4DecodeProperty (
                      PropItem,
                      DER_IMG4_ENCODE_PROPERTY_NAME (DER_IMG4_TAG_OBJ_DGST),
                      &Property
                      );
        if (DerResult != DR_Success) {
          return DerResult;
        }
 
        if (Property.valueTag != ASN1_OCTET_STRING) {
          return DR_UnexpectedTag;
        }
 
        if (Property.valueItem.length > sizeof (ManInfo->imageDigest)) {
          return DR_BufOverflow;
        }
 
        if (Property.valueItem.length == 0) {
          return DR_DecodeError;
        }
 
        DERMemmove (
          ManInfo->imageDigest,
          Property.valueItem.data,
          Property.valueItem.length
          );
        ManInfo->imageDigestSize = Property.valueItem.length;
 
        return DR_Success;
      }
 
      case DER_IMG4_TAG_OBJ_EKEY:
      {
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.enableKeys
                 );
      }
 
      default:
      {
        //
        // For forward compatibility, ignore unknown keys.
        //
        return DR_Success;
      }
    }
  } else {
    //
    // The conditional branches must be modified when more types are added.
    //
    assert (PropSetType == Img4ManifestPropSetTypeManp);
 
    switch (PropName) {
      case DER_IMG4_TAG_MAN_CEPO:
      {
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.certificateEpoch
                 );
      }
 
      case DER_IMG4_TAG_MAN_ECID:
      {
        ManInfo->hasEcid = true;
        DerResult = DERImg4DecodePropertyInteger64 (PropItem, PropName, &Ecid);
        if (DerResult == DR_Success) {
          ManInfo->environment.ecid = Ecid;
        }
 
        return DerResult;
      }
 
      case DER_IMG4_TAG_MAN_CHIP:
      {
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.chipId
                 );
      }
 
      case DER_IMG4_TAG_MAN_BORD:
      {
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.boardId
                 );
      }
 
      case DER_IMG4_TAG_MAN_AMNM:
      {
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.allowMixNMatch
                 );
      }
 
      case DER_IMG4_TAG_MAN_SDOM:
      {
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.securityDomain
                 );
      }
 
      case DER_IMG4_TAG_MAN_IUOB:
      {
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.internalUseOnlyUnit
                 );
      }
 
      case DER_IMG4_TAG_MAN_MPRO:
      {
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.productionStatus
                 );
      }
 
      case DER_IMG4_TAG_MAN_MSEC:
      {
        return DERImg4ManifestDecodePropertyBoolean (
                 PropItem,
                 PropName,
                 &ManInfo->environment.securityMode
                 );
      }
 
      case DER_IMG4_TAG_MAN_XUGS:
      {
        ManInfo->hasXugs = true;
        return DERImg4DecodePropertyInteger32 (
                 PropItem,
                 PropName,
                 &ManInfo->environment.xugs
                 );
      }
 
      default:
      {
        //
        // For forward compatibility, ignore unknown keys.
        //
        return DR_Success;
      }
    }
  }
}
 
DERReturn
DERImg4ManifestDecodeProperties (
  DERImg4ManifestInfo  *ManInfo,
  const DERItem        *PropSetItem,
  uint32_t             PropSetType
  )
{
  DERReturn       DerResult;
  DERReturn       LoopDerResult;
 
  DERSequence     PropSetSeq;
  DERDecodedInfo  PropInfo;
  DERImg4Property Property;
 
  assert (ManInfo != NULL);
  assert (PropSetItem != NULL);
 
  DerResult = DERDecodeSeqContentInit (PropSetItem, &PropSetSeq);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  while ((LoopDerResult = DERDecodeSeqNext (&PropSetSeq, &PropInfo)) == DR_Success) {
    DerResult = DERImg4DecodeProperty (
                  &PropInfo.content,
                  PropInfo.tag,
                  &Property
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
 
    if (Property.valueTag != ASN1_BOOLEAN
     && Property.valueTag != ASN1_INTEGER
     && Property.valueTag != ASN1_OCTET_STRING
     && Property.valueTag != ASN1_IA5_STRING
      ) {
      return DR_UnexpectedTag;
    }
 
    if ((PropInfo.tag & ASN1_CLASS_MASK) == 0
     || (PropInfo.tag & ASN1_CONSTRUCTED) == 0) {
      return DR_UnexpectedTag;
    }
 
    DerResult = DERImg4ManifestDecodeProperty (
                  &PropInfo.content,
                  (uint32_t)PropInfo.tag,
                  ManInfo,
                  PropSetType
                  );
    if (DerResult != DR_Success) {
      return DerResult;
    }
  }
 
  if (LoopDerResult != DR_EndOfSequence) {
    return LoopDerResult;
  }
 
  return DR_Success;
}
 
DERReturn
DERImg4ParseManifest (
  DERImg4ManifestInfo  *ManInfo,
  const void           *ManBuffer,
  size_t               ManSize,
  uint32_t             ObjType
  )
{
  DERReturn       DerResult;
 
  DERItem         ManifestItem;
  DERSize         DerManifestSize;
 
  DERDecodedInfo  ManifestInfo;
  DERImg4Manifest Manifest;
  uint32_t        ManVersion;
 
  DERDecodedInfo  ManBodyInfo;
  DERImg4Property ManBodyProp;
 
  DERImg4Property ManPropSetProp;
  DERImg4Property ObjPropSetProp;
 
  DERItem         ManBodyCertRoleItem;
 
  assert (ManInfo != NULL);
  assert (ManBuffer != NULL);
  assert (ManSize > 0);
  //
  // Verify the Manifest header integrity.
  //
  ManifestItem.data   = (DERByte *)ManBuffer;
  ManifestItem.length = ManSize;
  DerResult = DERDecodeItem (&ManifestItem, &ManifestInfo);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (ManifestInfo.tag != ASN1_CONSTR_SEQUENCE) {
    return DR_UnexpectedTag;
  }
  //
  // This is a guarantee libDER is supposed to make.
  //
  assert (ManifestInfo.content.data >= (DERByte *)ManBuffer);
 
  DerManifestSize  = (DERByte *)ManifestInfo.content.data - (DERByte *)ManBuffer;
  DerManifestSize += ManifestInfo.content.length;
  if (DerManifestSize != ManSize) {
    return DR_DecodeError;
  }
 
  DerResult = DERParseSequenceContent (
                &ManifestInfo.content,
                DERNumImg4ManifestItemSpecs,
                DERImg4ManifestItemSpecs,
                &Manifest,
                0
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (Manifest.body.data == NULL) {
    return DR_DecodeError;
  }
 
  DerResult = DERImg4ManifestVerifyMagic (&Manifest.magic);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4ParseInteger32 (&Manifest.version, &ManVersion);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (ManVersion != 0) {
    return DR_DecodeError;
  }
  //
  // Verify the Manifest body.
  //
  DerResult = DERImg4ManifestVerifySignature (&ManBodyCertRoleItem, &Manifest);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERDecodeItem (&Manifest.body, &ManBodyInfo);
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  if (ManBodyInfo.tag != ASN1_CONSTR_SET) {
    return DR_UnexpectedTag;
  }
 
  DerResult = DERImg4FindDecodeProperty (
                &ManBodyInfo.content,
                DER_IMG4_ENCODE_PROPERTY_NAME (DER_IMG4_TAG_MAN_BODY),
                ASN1_CONSTR_SET,
                &ManBodyProp
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4FindDecodeProperty (
                &ManBodyProp.valueItem,
                DER_IMG4_ENCODE_PROPERTY_NAME (DER_IMG4_TAG_MAN_PROPS),
                ASN1_CONSTR_SET,
                &ManPropSetProp
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4FindDecodeProperty (
                &ManBodyProp.valueItem,
                DER_IMG4_ENCODE_PROPERTY_NAME (ObjType),
                ASN1_CONSTR_SET,
                &ObjPropSetProp
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4ValidateCertificateRole (
                &ManPropSetProp.valueItem,
                &ObjPropSetProp.valueItem,
                &ManBodyCertRoleItem
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DERMemset (ManInfo, 0, sizeof (*ManInfo));
  //
  // Decode the Manifest body.
  //
  DerResult = DERImg4ManifestDecodeProperties (
                ManInfo,
                &ManPropSetProp.valueItem,
                Img4ManifestPropSetTypeManp
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  DerResult = DERImg4ManifestDecodeProperties (
                ManInfo,
                &ObjPropSetProp.valueItem,
                Img4ManifestPropSetTypeObjp
                );
  if (DerResult != DR_Success) {
    return DerResult;
  }
 
  return DR_Success;
}