Collect better FFDC on ROM verification errors

Collect both the UTIL and RUNTIME component traces on a ROM
verify failure
Added a new Errlog User Details sections "Verify Info" containing
the component name, ID(s), measured, and expected hashes

Change-Id: I0d0408128e05807bb906be5ee365d56d1416693f
CQ:SW413889
Backport:release-fips910
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/52593
Reviewed-by: Michael Baiocchi <mbaiocch@us.ibm.com>
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Marshall J. Wilks <mjwilks@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

9 files changed, 282 insertions, 18 deletions

diff --git a/src/usr/pnor/spnorrp.C b/src/usr/pnor/spnorrp.C
index 72a03d026..d2a907e71 100644
--- a/src/usr/pnor/spnorrp.C
+++ b/src/usr/pnor/spnorrp.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2011,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -531,7 +531,7 @@ uint64_t SPnorRP::verifySections(SectionId i_id,
         // verify while in temp space
         if (SECUREBOOT::enabled())
         {
-            l_errhdl = SECUREBOOT::verifyContainer(l_tempAddr);
+            l_errhdl = SECUREBOOT::verifyContainer(l_tempAddr, {i_id});
             if (l_errhdl)
             {
                 TRACFCOMP(g_trac_pnor, ERR_MRK"SPnorrRP::verifySections - section "
@@ -1460,6 +1460,7 @@ errlHndl_t SPnorRP::keyTransitionCheck(const uint8_t *i_vaddr) const
     }
 
     l_errl = SECUREBOOT::verifyContainer(l_nestedVaddr,
+                                         {PNOR::SBKT},
                                          l_nestedConHdr.hwKeyHash());
     if (l_errl)
     {
diff --git a/src/usr/secureboot/base/securerommgr.C b/src/usr/secureboot/base/securerommgr.C
index d5dac06d8..02eca6293 100644
--- a/src/usr/secureboot/base/securerommgr.C
+++ b/src/usr/secureboot/base/securerommgr.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -42,6 +42,7 @@
 #include <config.h>
 #include <console/consoleif.H>
 #include <secureboot/containerheader.H>
+#include "../common/errlud_secure.H"
 
 // Quick change for unit testing
 //#define TRACUCOMP(args...)  TRACFCOMP(args)
@@ -69,12 +70,15 @@ errlHndl_t initializeSecureRomManager(void)
 /**
  * @brief Verify Signed Container
  */
-errlHndl_t verifyContainer(void * i_container, const SHA512_t* i_hwKeyHash)
+errlHndl_t verifyContainer(void * i_container,  const RomVerifyIds& i_ids,
+                           const SHA512_t* i_hwKeyHash)
 {
     errlHndl_t l_errl = nullptr;
 
     l_errl = Singleton<SecureRomManager>::instance().
-                                       verifyContainer(i_container,i_hwKeyHash);
+                                       verifyContainer(i_container,
+                                                       i_ids,
+                                                       i_hwKeyHash);
 
     return l_errl;
 }
@@ -317,7 +321,8 @@ errlHndl_t SecureRomManager::initialize()
  * @brief Verify Container against system hash keys
  */
 errlHndl_t SecureRomManager::verifyContainer(void * i_container,
-                                      const SHA512_t* i_hwKeyHash)
+                                             const RomVerifyIds& i_ids,
+                                             const SHA512_t* i_hwKeyHash)
 {
     TRACDCOMP(g_trac_secure,ENTER_MRK"SecureRomManager::verifyContainer(): "
               "i_container=%p", i_container);
@@ -407,10 +412,42 @@ errlHndl_t SecureRomManager::verifyContainer(void * i_container,
                                          l_rc,
                                          l_hw_parms.log,
                                          true /*Add HB Software Callout*/ );
-            // Callout code to force a rewrite of the contents
-            //@todo RTC:93870 - Define new callout for verification fail
-            l_errl->collectTrace(PNOR_COMP_NAME,ERROR_TRACE_SIZE);
-            l_errl->collectTrace(SECURE_COMP_NAME,ERROR_TRACE_SIZE);
+            l_errl->collectTrace(PNOR_COMP_NAME);
+            l_errl->collectTrace(SECURE_COMP_NAME);
+            l_errl->collectTrace(UTIL_COMP_NAME);
+            l_errl->collectTrace(RUNTIME_COMP_NAME);
+
+            ContainerHeader l_conHdr;
+            auto l_hdrParseErr = l_conHdr.setHeader(i_container);
+            if (l_hdrParseErr)
+            {
+                TRACFCOMP(g_trac_secure, ERR_MRK"SecureRomManager::verifyContainer(): setheader failed");
+                // Link parse error log to existing errorlog plid and commit error
+                l_hdrParseErr->plid(l_errl->plid());
+                ERRORLOG::errlCommit(l_hdrParseErr, RUNTIME_COMP_ID);
+
+                // Add UD data without data needed from Container Header
+                UdVerifyInfo("UNKNOWN", 0, i_ids, {}, {}).addToLog(l_errl);
+            }
+            else
+            {
+                // Measure protected section. Note it starts one page after the
+                // vaddr passed in for verification
+                auto l_pProtectedSec =
+                    reinterpret_cast<const uint8_t*>(i_container) + PAGESIZE;
+                SHA512_t l_measuredHash = {0};
+                SECUREBOOT::hashBlob(l_pProtectedSec,
+                                     l_conHdr.payloadTextSize(),
+                                     l_measuredHash);
+                // Add UD data to errorlog
+                UdVerifyInfo(l_conHdr.componentId(),
+                             l_conHdr.payloadTextSize(),
+                             i_ids,
+                             l_measuredHash,
+                             *l_conHdr.payloadTextHash()
+                            ).addToLog(l_errl);
+            }
+
             break;
 
         }
diff --git a/src/usr/secureboot/base/securerommgr.H b/src/usr/secureboot/base/securerommgr.H
index 4358c4981..15644ce7f 100644
--- a/src/usr/secureboot/base/securerommgr.H
+++ b/src/usr/secureboot/base/securerommgr.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -53,12 +53,16 @@ class SecureRomManager
          *
          * @param[in] i_container  Void pointer to effective address
          *                          of container
+         * @param[in] i_ids  Vector of IDs (PNOR or Lid Id(s)) associated with
+         *                   the blob that is being verified.
+         *                   [default = empty vector]
          * @param[in] i_hwKeyHash  Custom hw keys' hash to test against
          *                         [default = nullptr, use current hw hash key
          *
          * @return errlHndl_t NULL on success
          */
         errlHndl_t verifyContainer(void * i_container,
+                                   const RomVerifyIds& i_ids = RomVerifyIds(),
                                    const SHA512_t* i_hwKeyHash = nullptr);
 
         /**
diff --git a/src/usr/secureboot/base/test/securerommgrtest.H b/src/usr/secureboot/base/test/securerommgrtest.H
index 3dee8952e..8ffa8375d 100644
--- a/src/usr/secureboot/base/test/securerommgrtest.H
+++ b/src/usr/secureboot/base/test/securerommgrtest.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -147,6 +147,7 @@ class SecureRomManagerTest : public CxxTest::TestSuite
         printkd("test_verify(): expect to see 'mfsr r2 to CFAR handled': ");
 
         l_errl = SECUREBOOT::verifyContainer(signedFile_pageAddr,
+                                             {},
                                              &hw_key_hash);
         if (l_errl)
         {
diff --git a/src/usr/secureboot/common/errlud_secure.C b/src/usr/secureboot/common/errlud_secure.C
index 1af61daba..68a0efcc1 100644
--- a/src/usr/secureboot/common/errlud_secure.C
+++ b/src/usr/secureboot/common/errlud_secure.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2014,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2014,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -31,6 +31,10 @@
 #include <secureboot/secure_reasoncodes.H>
 #include "errlud_secure.H"
 #include <kernel/bltohbdatamgr.H>
+#include <util/utilmem.H>
+#include <securerom/ROM.H>
+#include <errl/errlentry.H>
+#include <errl/errlmanager.H>
 
 namespace SECUREBOOT
 {
@@ -164,5 +168,50 @@ UdSecuritySettings::~UdSecuritySettings()
 
 }
 
+//------------------------------------------------------------------------------
+//  SECURE Verify Info User Details
+//------------------------------------------------------------------------------
+UdVerifyInfo::UdVerifyInfo(const char* i_compId,
+                           const uint64_t i_protectedSize,
+                           const RomVerifyIds& i_ids,
+                           const SHA512_t& i_measuredHash,
+                           const SHA512_t& i_expectedHash)
+{
+    // Set up Ud instance variables
+    iv_CompId = SECURE_COMP_ID;
+    iv_Version = SECURE_UDT_VERSION_1;
+    iv_SubSection = SECURE_UDT_VERIFY_INFO;
+
+    //***** Version SECURE_UDT_VERSION_1 Memory Layout *****
+    // 9 bytes Max : Component ID (8 byte string + NULL) use strlen
+    // 8 bytes     : Protected Payload Size
+    // 4 bytes   : Number of IDs
+    // 4*N bytes : IDs (PNOR id or LidID) multiplied by number of ids
+    // 64 bytes  : Measured Hash
+    // 64 bytes  : Expected Hash
+
+    UtilMem l_memBuf {};
+    l_memBuf.write(i_compId, strlen(i_compId)+1);
+    l_memBuf << i_protectedSize;
+    l_memBuf << static_cast<uint32_t>(i_ids.size());
+    for (auto id : i_ids)
+    {
+        l_memBuf << id;
+    }
+    l_memBuf.write(i_measuredHash, PARSER_SIZEOF_SHA512_t);
+    l_memBuf.write(i_expectedHash, PARSER_SIZEOF_SHA512_t);
+
+    auto l_memBufErr =  l_memBuf.getLastError();
+    if(l_memBufErr)
+    {
+        errlCommit(l_memBufErr,SECURE_COMP_ID);
+    }
+    else
+    {
+        char * l_pBuf = reinterpret_cast<char *>(reallocUsrBuf(l_memBuf.size()));
+        memcpy(l_pBuf, l_memBuf.base(), l_memBuf.size());
+    }
+}
+
 } // end SECUREBOOT namespace
 
diff --git a/src/usr/secureboot/common/errlud_secure.H b/src/usr/secureboot/common/errlud_secure.H
index dddc479eb..1e05399b1 100644
--- a/src/usr/secureboot/common/errlud_secure.H
+++ b/src/usr/secureboot/common/errlud_secure.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2017                             */
+/* Contributors Listed Below - COPYRIGHT 2017,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -174,6 +174,55 @@ class UdSecuritySettings : public ERRORLOG::ErrlUserDetails
 
 };
 
+/**
+ * @class UdVerifyInfo
+ *
+ * Adds Secure verification info to an error log as user detail data
+ */
+class UdVerifyInfo : public ERRORLOG::ErrlUserDetails
+{
+  public:
+    /**
+     *  @brief Constructor
+     *  @param[in] i_compId  Component ID associated with blob being verified
+     *  @param[in] i_protectedSize  Protected Payload Size
+     *  @param[in] i_ids  Vector of IDs (PNOR or Lid Id(s)) associated with
+     *                    the blob that is being verified.
+     *  @param[in] i_measuredHash  Measured SHA512 Hash
+     *  @param[in] i_expectedHash  Expected SHA512 Hash
+     */
+    UdVerifyInfo(const char* i_compId,
+                 const uint64_t i_protectedSize,
+                 const RomVerifyIds& i_ids,
+                 const SHA512_t& i_measuredHash,
+                 const SHA512_t& i_expectedHash);
+
+    /**
+     *  @brief Destructor
+     */
+    virtual ~UdVerifyInfo() {}
+
+    /**
+     * Delete Copy Constructor
+     */
+    UdVerifyInfo(const UdVerifyInfo&) = delete;
+
+    /**
+     * Delete Copy Assignment
+     */
+    UdVerifyInfo& operator= (const UdVerifyInfo&) = delete;
+
+    /**
+     * Delete Move Constructor
+     */
+    UdVerifyInfo (UdVerifyInfo&&) = delete;
+
+    /**
+     * Delete Move Assignment
+     */
+    UdVerifyInfo& operator = (UdVerifyInfo&&) = delete;
+};
+
 } // end SECUREBOOT namespace
 
 #endif
diff --git a/src/usr/secureboot/common/plugins/errludP_secure.H b/src/usr/secureboot/common/plugins/errludP_secure.H
index 39a8126d6..817967bbf 100644
--- a/src/usr/secureboot/common/plugins/errludP_secure.H
+++ b/src/usr/secureboot/common/plugins/errludP_secure.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2017                             */
+/* Contributors Listed Below - COPYRIGHT 2017,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -33,12 +33,15 @@
 
 #include "errluserdetails.H"
 #include <string.h>
+#include <utilmem.H>
 
 /**
  * Some macros to manipulate data types cleanly
  */
 #define TO_UINT8(ptr)   (*(reinterpret_cast<uint8_t*>(ptr)))
+#define TO_UINT16(ptr)  (ntohs(*(reinterpret_cast<uint16_t*>(ptr))))
 #define TO_UINT32(ptr)  (ntohl(*(reinterpret_cast<uint32_t*>(ptr))))
+#define TO_UINT64(ptr)  (ntohll(*(reinterpret_cast<uint64_t*>(ptr))))
 
 namespace SECUREBOOT
 {
@@ -47,6 +50,7 @@ namespace SECUREBOOT
  */
 enum {
     UDPARSER_SIZEOF_SHA512_t           = 64,
+    UDPARSER_SIZEOF_MAX_VERIFY_IDS     = 50,
 };
 
 /**
@@ -229,6 +233,106 @@ class UdParserSecuritySettings : public ERRORLOG::ErrlUserDetailsParser
     };
 };
 
+/**
+ * @class UdParserVerifyInfo
+ *
+ * Parses UdSecureVerifyInfo
+ */
+class UdParserVerifyInfo : public ERRORLOG::ErrlUserDetailsParser
+{
+  public:
+    /**
+     *  @brief Constructor
+     */
+    UdParserVerifyInfo() {}
+
+    /**
+     *  @brief Destructor
+     */
+    virtual ~UdParserVerifyInfo() {}
+
+    /**
+     *  @brief Parses verify container user detail data from an error log
+     *
+     *  @param  i_version Version of the data
+     *  @param  i_parse   ErrlUsrParser object for outputting information
+     *  @param  i_pBuffer Pointer to buffer containing detail data
+     *  @param  i_buflen  Length of the buffer
+     */
+    virtual void parse(errlver_t i_version,
+                       ErrlUsrParser & i_parser,
+                       void * i_pBuffer,
+                       const uint32_t i_buflen) const
+    {
+        //***** Version 1 Memory Layout *****
+        // 9 bytes Max : Component ID (8 byte string + NULL) use strlen
+        // 8 bytes     : Protected Payload Size
+        // 4 bytes     : Number of IDs
+        // 4*N bytes   : IDs (PNOR id or LidID) multiplied by number of ids
+        // 64 bytes    : Measured Hash
+        // 64 bytes    : Expected Hash
+
+        char* l_databuf = static_cast<char*>(i_pBuffer);
+        bool l_parseError = false;
+
+        do {
+        i_parser.PrintHeading("Secure Verify Info");
+        if (i_version >= 1)
+        {
+            // Component ID
+            i_parser.PrintString("Component ID", l_databuf);
+            // Skip string plus 1 byte for null termination
+            l_databuf += strlen(l_databuf)+1;
+
+            // Number of IDs
+            uint64_t l_protectedSize = TO_UINT64(l_databuf);
+            i_parser.PrintNumberUint64("Protected Payload Size","0x%016llX",
+                                        l_protectedSize);
+            l_databuf += sizeof(l_protectedSize);
+
+            // Number of IDs
+            uint32_t l_numIds = TO_UINT32(l_databuf);
+            i_parser.PrintNumber("Number of IDs","%d", l_numIds);
+            l_databuf += sizeof(l_numIds);
+
+            // IDs
+            i_parser.PrintHeading("ID(s)");
+            for (uint32_t i = 0; i < l_numIds; ++i)
+            {
+                i_parser.PrintNumber("ID","0x%08lX", TO_UINT32(l_databuf));
+                l_databuf += sizeof(uint32_t);
+                // In case of bad format, don't go past max size
+                if(i >= UDPARSER_SIZEOF_MAX_VERIFY_IDS)
+                {
+                    l_parseError = true;
+                    break;
+                }
+            }
+            // In case of bad format, don't continue to parse section
+            if(l_parseError)
+            {
+                break;
+            }
+
+            // Measured Hash
+            i_parser.PrintHeading("Measured Hash");
+            i_parser.PrintHexDump(l_databuf, UDPARSER_SIZEOF_SHA512_t);
+            l_databuf += UDPARSER_SIZEOF_SHA512_t;
+
+            /// Expected Hash
+            i_parser.PrintHeading("Expected Hash");
+            i_parser.PrintHexDump(l_databuf, UDPARSER_SIZEOF_SHA512_t);
+            l_databuf += UDPARSER_SIZEOF_SHA512_t;
+        }
+        } while(0);
+
+    }
+
+  private:
+    // Disabled
+    UdParserVerifyInfo(const UdParserVerifyInfo&);
+    UdParserVerifyInfo & operator=(const UdParserVerifyInfo&);
+};
 
 
 } // end SECUREBOOT namespace
diff --git a/src/usr/secureboot/common/plugins/secureUdParserFactory.H b/src/usr/secureboot/common/plugins/secureUdParserFactory.H
index 5b6d540fa..d720c1ce1 100644
--- a/src/usr/secureboot/common/plugins/secureUdParserFactory.H
+++ b/src/usr/secureboot/common/plugins/secureUdParserFactory.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2017                             */
+/* Contributors Listed Below - COPYRIGHT 2017,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -44,6 +44,9 @@ namespace SECUREBOOT
 
                 registerParser<SECUREBOOT::UdParserSecuritySettings>
                   (SECURE_UDT_SECURITY_SETTINGS);
+
+                registerParser<SECUREBOOT::UdParserVerifyInfo>
+                  (SECURE_UDT_VERIFY_INFO);
             }
 
         private:
diff --git a/src/usr/util/utilmclmgr.C b/src/usr/util/utilmclmgr.C
index 9112e4765..bcf0432bb 100644
--- a/src/usr/util/utilmclmgr.C
+++ b/src/usr/util/utilmclmgr.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2017                             */
+/* Contributors Listed Below - COPYRIGHT 2017,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -59,6 +59,17 @@ uint64_t compIdToInt(const ComponentID i_compId)
     return l_compId;
 }
 
+RomVerifyIds extractLidIds(const std::vector<LidInfo>& i_lidIds)
+{
+    RomVerifyIds l_ids {};
+    for (auto const& id : i_lidIds)
+    {
+        l_ids.push_back(id.id);
+    }
+
+    return l_ids;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // CompInfo
 ////////////////////////////////////////////////////////////////////////////////
@@ -317,12 +328,15 @@ void MasterContainerLidMgr::parseMcl()
 
 void MasterContainerLidMgr::printCompInfoCache()
 {
+    // Use ifdef as we do not want CompInfo print to be debug only
+#ifdef HOSTBOOT_DEBUG
     UTIL_FT("> MCL Comp Info cache:");
     for (const auto &i : iv_compInfoCache)
     {
         UTIL_FBIN("- Comp Id:", &i.first, sizeof(ComponentID));
         i.second.print();
     }
+#endif
 }
 
 errlHndl_t MasterContainerLidMgr::processComponents()
@@ -595,7 +609,9 @@ errlHndl_t MasterContainerLidMgr::verifyExtend(const ComponentID& i_compId,
         if (SECUREBOOT::enabled())
         {
             // Verify Container - some combination of Lids
-            l_errl = SECUREBOOT::verifyContainer(iv_pVaddr);
+
+            l_errl = SECUREBOOT::verifyContainer(iv_pVaddr,
+                                             extractLidIds(io_compInfo.lidIds));
             if (l_errl)
             {
                 UTIL_FT(ERR_MRK"MasterContainerLidMgr::verifyExtend - failed verifyContainer");