diff --git a/src/fru_device/fru_device.cpp b/src/fru_device/fru_device.cpp
index 324afcd..2363477 100644
--- a/src/fru_device/fru_device.cpp
+++ b/src/fru_device/fru_device.cpp
@@ -958,7 +958,6 @@
             return false;
         }
 
-        std::array<uint8_t, I2C_SMBUS_BLOCK_MAX> blockData{};
         std::string errorMessage = "eeprom at " + std::to_string(bus) +
                                    " address " + std::to_string(address);
         auto readFunc = [eeprom](off_t offset, size_t length, uint8_t* outbuf) {
@@ -966,10 +965,15 @@
         };
         FRUReader reader(std::move(readFunc));
 
-        if (!findFRUHeader(reader, errorMessage, blockData, offset))
+        auto sections = findFRUHeader(reader, errorMessage, 0);
+        if (!sections)
         {
             offset = 0;
         }
+        else
+        {
+            offset = sections->IpmiFruOffset;
+        }
 
         if (lseek(eeprom, offset, SEEK_SET) < 0)
         {
diff --git a/src/fru_device/fru_utils.cpp b/src/fru_device/fru_utils.cpp
index c9669de..efb4ec1 100644
--- a/src/fru_device/fru_utils.cpp
+++ b/src/fru_device/fru_utils.cpp
@@ -3,6 +3,8 @@
 
 #include "fru_utils.hpp"
 
+#include "gzip_utils.hpp"
+
 #include <phosphor-logging/lg2.hpp>
 
 #include <array>
@@ -717,27 +719,66 @@
     return true;
 }
 
-bool findFRUHeader(FRUReader& reader, const std::string& errorHelp,
-                   std::array<uint8_t, I2C_SMBUS_BLOCK_MAX>& blockData,
-                   off_t& baseOffset)
+std::string parseMacFromGzipXmlHeader(FRUReader& reader, off_t offset)
 {
-    if (reader.read(baseOffset, 0x8, blockData.data()) < 0)
+    // gzip starts at offset 512. Read that from the FRU
+    // in this case, 32k bytes is enough to hold the whole manifest
+    constexpr size_t totalReadSize = 32UL * 1024UL;
+
+    std::vector<uint8_t> headerData(totalReadSize, 0U);
+
+    int rc = reader.read(offset, totalReadSize, headerData.data());
+    if (rc <= 0)
+    {
+        return {};
+    }
+
+    std::optional<std::string> xml = gzipInflate(headerData);
+    if (!xml)
+    {
+        return {};
+    }
+    std::vector<std::string> node = getNodeFromXml(
+        *xml, "/GSSKU/BoardInfo/Main/NIC/*[Mode = 'Dedicated']/MacAddr0");
+    if (node.empty())
+    {
+        lg2::debug("No mac address found in gzip xml header");
+        return {};
+    }
+    if (node.size() > 1)
+    {
+        lg2::warning("Multiple mac addresses found in gzip xml header");
+    }
+    return node[0];
+}
+
+std::optional<FruSections> findFRUHeader(
+    FRUReader& reader, const std::string& errorHelp, off_t startingOffset)
+{
+    std::array<uint8_t, I2C_SMBUS_BLOCK_MAX> blockData = {};
+    if (reader.read(startingOffset, 0x8, blockData.data()) < 0)
     {
         lg2::error("failed to read {ERR} base offset {OFFSET}", "ERR",
-                   errorHelp, "OFFSET", baseOffset);
-        return false;
+                   errorHelp, "OFFSET", startingOffset);
+        return std::nullopt;
     }
 
     // check the header checksum
     if (validateHeader(blockData))
     {
-        return true;
+        FruSections fru = {};
+        static_assert(fru.ipmiFruBlock.size() == blockData.size(),
+                      "size mismatch in block data");
+        std::memcpy(fru.ipmiFruBlock.data(), blockData.data(),
+                    I2C_SMBUS_BLOCK_MAX);
+        fru.IpmiFruOffset = startingOffset;
+        return fru;
     }
 
     // only continue the search if we just looked at 0x0.
-    if (baseOffset != 0)
+    if (startingOffset != 0)
     {
-        return false;
+        return std::nullopt;
     }
 
     // now check for special cases where the IPMI data is at an offset
@@ -748,8 +789,8 @@
         std::equal(tyanHeader.begin(), tyanHeader.end(), blockData.begin()))
     {
         // look for the FRU header at offset 0x6000
-        baseOffset = 0x6000;
-        return findFRUHeader(reader, errorHelp, blockData, baseOffset);
+        off_t tyanOffset = 0x6000;
+        return findFRUHeader(reader, errorHelp, tyanOffset);
     }
 
     // check if blockData starts with gigabyteHeader
@@ -760,27 +801,39 @@
                    blockData.begin()))
     {
         // look for the FRU header at offset 0x4000
-        baseOffset = 0x4000;
-        return findFRUHeader(reader, errorHelp, blockData, baseOffset);
+        off_t gbOffset = 0x4000;
+        auto sections = findFRUHeader(reader, errorHelp, gbOffset);
+        if (sections)
+        {
+            lg2::debug("succeeded on GB parse");
+            // GB xml header is at 512 bytes
+            sections->GigabyteXmlOffset = 512;
+        }
+        else
+        {
+            lg2::error("Failed on GB parse");
+        }
+        return sections;
     }
 
     lg2::debug("Illegal header {HEADER} base offset {OFFSET}", "HEADER",
-               errorHelp, "OFFSET", baseOffset);
+               errorHelp, "OFFSET", startingOffset);
 
-    return false;
+    return std::nullopt;
 }
 
 std::pair<std::vector<uint8_t>, bool> readFRUContents(
     FRUReader& reader, const std::string& errorHelp)
 {
     std::array<uint8_t, I2C_SMBUS_BLOCK_MAX> blockData{};
-    off_t baseOffset = 0x0;
-
-    if (!findFRUHeader(reader, errorHelp, blockData, baseOffset))
+    std::optional<FruSections> sections = findFRUHeader(reader, errorHelp, 0);
+    if (!sections)
     {
         return {{}, false};
     }
-
+    const off_t baseOffset = sections->IpmiFruOffset;
+    std::memcpy(blockData.data(), sections->ipmiFruBlock.data(),
+                blockData.size());
     std::vector<uint8_t> device;
     device.insert(device.end(), blockData.begin(),
                   std::next(blockData.begin(), 8));
@@ -897,6 +950,20 @@
         fruLength -= std::min(requestLength, fruLength);
     }
 
+    if (sections->GigabyteXmlOffset != 0)
+    {
+        std::string macAddress =
+            parseMacFromGzipXmlHeader(reader, sections->GigabyteXmlOffset);
+        if (!macAddress.empty())
+        {
+            // launder the mac address as we expect into
+            // BOARD_INFO_AM2 to allow the rest of the
+            // system to use it
+            std::string mac = std::format("MAC: {}", macAddress);
+            updateAddProperty(mac, "BOARD_INFO_AM2", device);
+        }
+    }
+
     return {device, true};
 }
 
diff --git a/src/fru_device/fru_utils.hpp b/src/fru_device/fru_utils.hpp
index 0491b30..d689d5c 100644
--- a/src/fru_device/fru_utils.hpp
+++ b/src/fru_device/fru_utils.hpp
@@ -126,6 +126,14 @@
 
 ssize_t getFieldLength(uint8_t fruFieldTypeLenValue);
 
+struct FruSections
+{
+    off_t IpmiFruOffset = 0;
+    std::array<uint8_t, I2C_SMBUS_BLOCK_MAX> ipmiFruBlock;
+
+    off_t GigabyteXmlOffset = 0;
+};
+
 /// \brief Find a FRU header.
 /// \param reader the FRUReader to read via
 /// \param errorHelp and a helper string for failures
@@ -134,9 +142,8 @@
 ///        set to 0 to perform search;
 ///        returns the offset at which a header was found
 /// \return whether a header was found
-bool findFRUHeader(FRUReader& reader, const std::string& errorHelp,
-                   std::array<uint8_t, I2C_SMBUS_BLOCK_MAX>& blockData,
-                   off_t& baseOffset);
+std::optional<FruSections> findFRUHeader(
+    FRUReader& reader, const std::string& errorHelp, off_t offset);
 
 /// \brief Read and validate FRU contents.
 /// \param reader the FRUReader to read via
@@ -229,4 +236,6 @@
 
 bool updateAddProperty(const std::string& propertyValue,
                        const std::string& propertyName,
-                       std::vector<uint8_t>& data);
+                       std::vector<uint8_t>& fruData);
+
+std::string parseMacFromGzipXmlHeader(FRUReader& reader, off_t offset);
diff --git a/src/fru_device/gzip_utils.cpp b/src/fru_device/gzip_utils.cpp
new file mode 100644
index 0000000..430fb91
--- /dev/null
+++ b/src/fru_device/gzip_utils.cpp
@@ -0,0 +1,111 @@
+#include "gzip_utils.hpp"
+
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <unistd.h>
+#include <zlib.h>
+
+#include <optional>
+#include <span>
+#include <string>
+#include <vector>
+
+std::optional<std::string> gzipInflate(std::span<uint8_t> compressedBytes)
+{
+    std::string uncompressedBytes;
+    if (compressedBytes.empty())
+    {
+        return std::nullopt;
+    }
+
+    z_stream strm{
+
+    };
+    strm.next_in = (Bytef*)compressedBytes.data();
+    strm.avail_in = static_cast<uInt>(compressedBytes.size());
+    strm.total_out = 0;
+
+    if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK)
+    {
+        return std::nullopt;
+    }
+
+    while (strm.avail_in > 0)
+    {
+        constexpr size_t chunkSize = 1024;
+        uncompressedBytes.resize(uncompressedBytes.size() + chunkSize);
+        strm.next_out =
+            std::bit_cast<Bytef*>(uncompressedBytes.end() - chunkSize);
+        strm.avail_out = chunkSize;
+
+        // Inflate another chunk.
+        int err = inflate(&strm, Z_SYNC_FLUSH);
+        if (err == Z_STREAM_END)
+        {
+            break;
+        }
+        if (err != Z_OK)
+        {
+            return std::nullopt;
+        }
+    }
+
+    if (inflateEnd(&strm) != Z_OK)
+    {
+        return std::nullopt;
+    }
+    uncompressedBytes.resize(strm.total_out);
+
+    return {uncompressedBytes};
+}
+
+static std::vector<std::string> xpathText(xmlDocPtr doc, const char* xp)
+{
+    std::vector<std::string> val;
+    xmlXPathContextPtr ctx = xmlXPathNewContext(doc);
+    if (ctx == nullptr)
+    {
+        return val;
+    }
+    const unsigned char* xpptr = std::bit_cast<const unsigned char*>(xp);
+    xmlXPathObjectPtr obj = xmlXPathEvalExpression(xpptr, ctx);
+    if (obj != nullptr)
+    {
+        if (obj->type == XPATH_NODESET && obj->nodesetval != nullptr)
+        {
+            xmlNodeSetPtr nodeTab = obj->nodesetval;
+            size_t nodeNr = static_cast<size_t>(nodeTab->nodeNr);
+            std::span<xmlNodePtr> nodes{nodeTab->nodeTab, nodeNr};
+            for (xmlNodePtr node : nodes)
+            {
+                unsigned char* keyword = xmlNodeGetContent(node);
+                val.emplace_back(std::bit_cast<const char*>(keyword));
+                xmlFree(keyword);
+            }
+        }
+    }
+
+    xmlXPathFreeObject(obj);
+    xmlXPathFreeContext(ctx);
+    return val;
+}
+
+std::vector<std::string> getNodeFromXml(std::string_view xml,
+                                        const char* nodeName)
+{
+    std::vector<std::string> node;
+    if (xml.empty())
+    {
+        return node;
+    }
+    xmlDocPtr doc = xmlReadMemory(
+        xml.data(), xml.size(), nullptr, nullptr,
+        XML_PARSE_RECOVER | XML_PARSE_NONET | XML_PARSE_NOWARNING);
+    if (doc == nullptr)
+    {
+        return {};
+    }
+    node = xpathText(doc, nodeName);
+    xmlFreeDoc(doc);
+    return node;
+}
diff --git a/src/fru_device/gzip_utils.hpp b/src/fru_device/gzip_utils.hpp
new file mode 100644
index 0000000..db94a89
--- /dev/null
+++ b/src/fru_device/gzip_utils.hpp
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2018 Intel Corporation
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string>
+#include <vector>
+
+std::optional<std::string> gzipInflate(std::span<uint8_t> compressedBytes);
+
+std::vector<std::string> getNodeFromXml(std::string_view xml,
+                                        const char* nodeName);
diff --git a/src/fru_device/meson.build b/src/fru_device/meson.build
index 0197f77..b99d0d8 100644
--- a/src/fru_device/meson.build
+++ b/src/fru_device/meson.build
@@ -13,17 +13,20 @@
     'fru-device',
     'fru_device.cpp',
     '../utils.cpp',
-    'fru_utils.cpp',
     'fru_reader.cpp',
+    'fru_utils.cpp',
+    'gzip_utils.cpp',
     cpp_args: cpp_args_fd,
     dependencies: [
         boost,
         i2c,
+        libxml2_dep,
         nlohmann_json_dep,
         phosphor_logging_dep,
         sdbusplus,
         threads,
         valijson,
+        zlib_dep,
     ],
     install: true,
     install_dir: installdir,