diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ac9f720
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+Hoth IPMI Blob Handler
diff --git a/command/dbus_command.cpp b/command/dbus_command.cpp
new file mode 100644
index 0000000..c61910a
--- /dev/null
+++ b/command/dbus_command.cpp
@@ -0,0 +1,69 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus_command.hpp"
+
+#include "dbus_command_impl.hpp"
+
+#include <fmt/format.h>
+
+#include <stdplus/cancel.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+stdplus::Cancel DbusCommandImpl::SendHostCommand(
+    std::string_view hothId, const std::vector<uint8_t>& cmd, Cb&& cb)
+{
+    auto req = newHothdCall(hothId, "SendHostCommand");
+    req.append(cmd);
+    auto cHothId = std::string(hothId);
+    return stdplus::Cancel(new BusCall(req.call_async(
+        [cb = std::move(cb), hothId = std::move(cHothId)](
+            sdbusplus::message::message m) mutable noexcept {
+            if (m.is_method_error())
+            {
+                auto err = m.get_error();
+                fmt::print(stderr, "SendHostCommand failed on `{}`: {}: {}\n",
+                           hothId, err->name, err->message);
+                cb(std::nullopt);
+                return;
+            }
+            try
+            {
+                std::vector<uint8_t> rsp;
+                m.read(rsp);
+                cb(std::move(rsp));
+            }
+            catch (const std::exception& e)
+            {
+                fmt::print(stderr,
+                           "SendHostCommand failed unpacking on `{}`: {}\n",
+                           hothId, e.what());
+                cb(std::nullopt);
+            }
+        },
+        asyncCallTimeout)));
+}
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/command/dbus_command.hpp b/command/dbus_command.hpp
new file mode 100644
index 0000000..cafbae7
--- /dev/null
+++ b/command/dbus_command.hpp
@@ -0,0 +1,53 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus.hpp"
+
+#include <function2/function2.hpp>
+#include <stdplus/cancel.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class DbusCommand
+ *  @brief Overridable D-Bus interface for command handler
+ */
+class DbusCommand : public virtual Dbus
+{
+  public:
+    using Cb = fu2::unique_function<void(std::optional<std::vector<uint8_t>>)>;
+
+    /** @brief Implementation for asynchronous SendHostCommand
+     *  Send a host command to Hoth and run a callback when it responds.
+     *
+     *  @param[in] hothId - The identifier of the targeted hoth instance.
+     *  @param[in] command - Data to write to Hoth SPI host command offset.
+     *  @param[in] cb      - The callback to execute.
+     *  @return cancelable[stdplus::Cancel] - Drop to cancel the command early.
+     */
+    virtual stdplus::Cancel SendHostCommand(
+        std::string_view hothId, const std::vector<uint8_t>&, Cb&&) = 0;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/command/dbus_command_impl.hpp b/command/dbus_command_impl.hpp
new file mode 100644
index 0000000..cf25106
--- /dev/null
+++ b/command/dbus_command_impl.hpp
@@ -0,0 +1,44 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_command.hpp"
+#include "dbus_impl.hpp"
+
+#include <sdbusplus/bus.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class DbusImpl
+ *  @brief D-Bus concrete implementation
+ *  @details Pass through all calls to the default D-Bus instance
+ */
+class DbusCommandImpl : public DbusCommand, public DbusImpl
+{
+  public:
+    stdplus::Cancel SendHostCommand(std::string_view hothId,
+                                    const std::vector<uint8_t>&, Cb&&) override;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/command/hoth_command.cpp b/command/hoth_command.cpp
new file mode 100644
index 0000000..931d5a8
--- /dev/null
+++ b/command/hoth_command.cpp
@@ -0,0 +1,94 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command.hpp"
+
+#include <phosphor-logging/log.hpp>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+using phosphor::logging::entry;
+using phosphor::logging::log;
+
+using level = phosphor::logging::level;
+using SdBusError = sdbusplus::exception::SdBusError;
+
+namespace ipmi_hoth
+{
+
+bool HothCommandBlobHandler::stat(const std::string&, blobs::BlobMeta*)
+{
+    /* Hoth command handler does not support a global blob stat. */
+    return false;
+}
+
+bool HothCommandBlobHandler::commit(uint16_t session,
+                                    const std::vector<uint8_t>& data)
+{
+    if (!data.empty())
+    {
+        log<level::ERR>("Unexpected data provided to commit call");
+        return false;
+    }
+
+    HothBlob* sess = getSession(session);
+    if (!sess)
+    {
+        return false;
+    }
+
+    // If commit is called multiple times, return the same result as last time
+    if (sess->state &
+        (blobs::StateFlags::committing | blobs::StateFlags::committed))
+    {
+        return true;
+    }
+
+    sess->state &= ~blobs::StateFlags::commit_error;
+    sess->state |= blobs::StateFlags::committing;
+    sess->outstanding = dbus_->SendHostCommand(
+        sess->hothId, sess->buffer,
+        [sess](std::optional<std::vector<uint8_t>> rsp) {
+            auto outstanding = std::move(sess->outstanding);
+            sess->state &= ~blobs::StateFlags::committing;
+            if (!rsp)
+            {
+                sess->state |= blobs::StateFlags::commit_error;
+                return;
+            }
+            sess->buffer = std::move(*rsp);
+            sess->state |= blobs::StateFlags::committed;
+        });
+    return true;
+}
+
+bool HothCommandBlobHandler::stat(uint16_t session, blobs::BlobMeta* meta)
+{
+    HothBlob* sess = getSession(session);
+    if (!sess)
+    {
+        return false;
+    }
+
+    meta->size = sess->buffer.size();
+    meta->blobState = sess->state;
+    return true;
+}
+
+} // namespace ipmi_hoth
diff --git a/command/hoth_command.hpp b/command/hoth_command.hpp
new file mode 100644
index 0000000..64e9a43
--- /dev/null
+++ b/command/hoth_command.hpp
@@ -0,0 +1,67 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_command.hpp"
+#include "hoth.hpp"
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+
+class HothCommandBlobHandler : public HothBlobHandler
+{
+  public:
+    explicit HothCommandBlobHandler(internal::DbusCommand* dbus) : dbus_(dbus)
+    {}
+
+    /* Our callbacks require pinned memory */
+    HothCommandBlobHandler(HothCommandBlobHandler&&) = delete;
+    HothCommandBlobHandler& operator=(HothCommandBlobHandler&&) = delete;
+
+    bool stat(const std::string& path, blobs::BlobMeta* meta) override;
+    bool commit(uint16_t session, const std::vector<uint8_t>& data) override;
+    bool stat(uint16_t session, blobs::BlobMeta* meta) override;
+
+    internal::Dbus& dbus() override
+    {
+        return *dbus_;
+    }
+    std::string_view pathSuffix() const override
+    {
+        return "command_passthru";
+    }
+    uint16_t requiredFlags() const override
+    {
+        return blobs::OpenFlags::read | blobs::OpenFlags::write;
+    }
+    uint16_t maxSessions() const override
+    {
+        return 10;
+    }
+    uint32_t maxBufferSize() const override
+    {
+        return 1024;
+    }
+
+  private:
+    internal::DbusCommand* dbus_;
+};
+
+} // namespace ipmi_hoth
diff --git a/command/main_command.cpp b/command/main_command.cpp
new file mode 100644
index 0000000..f7dfdee
--- /dev/null
+++ b/command/main_command.cpp
@@ -0,0 +1,29 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus_command_impl.hpp"
+#include "hoth_command.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <memory>
+
+extern "C" std::unique_ptr<blobs::GenericBlobInterface> createHandler()
+{
+    /** @brief Default instantiation of Dbus */
+    static ipmi_hoth::internal::DbusCommandImpl dbusCommand_impl;
+
+    return std::make_unique<ipmi_hoth::HothCommandBlobHandler>(
+        &dbusCommand_impl);
+}
diff --git a/command/meson.build b/command/meson.build
new file mode 100644
index 0000000..63360ca
--- /dev/null
+++ b/command/meson.build
@@ -0,0 +1,40 @@
+# Function2 might not have a pkg-config. It is header only so just make
+# sure we can access the needed symbols from the header.
+function2_dep = dependency('function2', required: false)
+has_function2 = meson.get_compiler('cpp').has_header_symbol(
+  'function2/function2.hpp',
+  'fu2::unique_function',
+  dependencies: function2_dep)
+
+hothcommand_pre = declare_dependency(
+  include_directories: include_directories('.'),
+  dependencies: [
+    function2_dep,
+    hothblob_dep,
+    phosphor_logging_dep,
+    sdbusplus_dep,
+    stdplus_dep,
+  ])
+
+hothcommand_lib = static_library(
+  'hothcommand',
+  'dbus_command.cpp',
+  'hoth_command.cpp',
+  implicit_include_directories: false,
+  dependencies: hothcommand_pre)
+
+hothcommand_dep = declare_dependency(
+  link_with: hothcommand_lib,
+  dependencies: hothcommand_pre)
+
+shared_module(
+  'hothcommand',
+  'main_command.cpp',
+  implicit_include_directories: false,
+  dependencies: hothcommand_dep,
+  install: true,
+  install_dir: get_option('libdir') / 'blob-ipmid')
+
+if not get_option('tests').disabled()
+  subdir('test')
+endif
diff --git a/command/test/dbus_command_mock.hpp b/command/test/dbus_command_mock.hpp
new file mode 100644
index 0000000..5231ca3
--- /dev/null
+++ b/command/test/dbus_command_mock.hpp
@@ -0,0 +1,41 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_command.hpp"
+#include "dbus_mock.hpp"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gmock/gmock.h>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+class DbusCommandMock : public DbusCommand, public DbusMock
+{
+  public:
+    MOCK_METHOD(stdplus::Cancel, SendHostCommand,
+                (std::string_view, const std::vector<uint8_t>&, Cb&&),
+                (override));
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_close_unittest.cpp b/command/test/hoth_command_close_unittest.cpp
new file mode 100644
index 0000000..841ff39
--- /dev/null
+++ b/command/test/hoth_command_close_unittest.cpp
@@ -0,0 +1,46 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothCommandCloseTest : public HothCommandTest
+{};
+
+TEST_F(HothCommandCloseTest, CloseWithInvalidSessionFails)
+{
+    // Verify you cannot close an invalid session.
+
+    EXPECT_FALSE(hvn.close(session_));
+}
+
+TEST_F(HothCommandCloseTest, CloseWithValidSessionSuccess)
+{
+    // Verify you can close a valid session.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.close(session_));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_commit_unittest.cpp b/command/test/hoth_command_commit_unittest.cpp
new file mode 100644
index 0000000..495aa59
--- /dev/null
+++ b/command/test/hoth_command_commit_unittest.cpp
@@ -0,0 +1,241 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <sdbusplus/exception.hpp>
+#include <sdbusplus/test/sdbus_mock.hpp>
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::IsEmpty;
+using ::testing::NotNull;
+using ::testing::Return;
+
+using namespace std::literals;
+
+namespace ipmi_hoth
+{
+
+const auto static test_str = "Hello, world!"s;
+const std::vector<uint8_t> static test_buf(test_str.begin(), test_str.end());
+const auto static test2_str = "Good morning, world!"s;
+const std::vector<uint8_t> static test2_buf(test2_str.begin(), test2_str.end());
+
+sdbusplus::SdBusMock sdbusIntf;
+
+ACTION(SdbusThrow)
+{
+    EXPECT_CALL(sdbusIntf, sd_bus_error_set_errno(NotNull(), _))
+        .WillOnce(Return(0));
+    EXPECT_CALL(sdbusIntf, sd_bus_error_is_set(NotNull())).WillOnce(Return(1));
+    EXPECT_CALL(sdbusIntf, sd_bus_error_free(NotNull())).Times(1);
+
+    throw sdbusplus::exception::SdBusError(0, "", &sdbusIntf);
+}
+
+class HothCommandCommitTest : public HothCommandTest
+{
+  protected:
+    void expectValidCommand(std::string_view name,
+                            const std::vector<uint8_t>& input)
+    {
+        EXPECT_CALL(dbus, SendHostCommand(name, ContainerEq(input), _))
+            .WillOnce([&](auto, const auto&, auto cb) {
+                this->cb = std::move(cb);
+                return stdplus::Cancel(std::nullopt);
+            });
+    }
+    internal::DbusCommand::Cb cb;
+};
+
+TEST_F(HothCommandCommitTest, InvalidSessionCommitIsRejected)
+{
+    // Verify the hoth command handler checks for a valid session.
+
+    EXPECT_FALSE(hvn.commit(session_, std::vector<uint8_t>()));
+}
+
+TEST_F(HothCommandCommitTest, UnexpectedDataParam)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.commit(session_, std::vector<uint8_t>({1, 2, 3})));
+}
+
+TEST_F(HothCommandCommitTest, DbusCallFail)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectValidCommand("", test_buf);
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    cb(std::nullopt);
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::commit_error | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+TEST_F(HothCommandCommitTest, EmptyLegacyHoth)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectValidCommand("", {});
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    cb(std::vector<uint8_t>{});
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(0, meta.size);
+    EXPECT_EQ(blobs::StateFlags::committed | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+TEST_F(HothCommandCommitTest, EmptyNamedHoth)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(name))).WillOnce(Return(true));
+    expectValidCommand(name, {});
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), namedPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    cb(std::vector<uint8_t>{});
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(0, meta.size);
+    EXPECT_EQ(blobs::StateFlags::committed | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+// Tests the full commit process with example data
+TEST_F(HothCommandCommitTest, HappyPath)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectValidCommand("", test_buf);
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    cb(test2_buf);
+
+    std::vector<uint8_t> result = hvn.read(session_, 0, test2_buf.size());
+    EXPECT_THAT(result, ContainerEq(test2_buf));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(blobs::StateFlags::committed | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+// Tests that repeated commits only result in one D-Bus call
+TEST_F(HothCommandCommitTest, IdempotentSuccess)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectValidCommand("", {});
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    cb(std::vector<uint8_t>{});
+
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committed | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+// Tests that repeated commits will retry DBus calls if there is an error
+TEST_F(HothCommandCommitTest, ErrorRetry)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectValidCommand("", {});
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    cb(std::nullopt);
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::commit_error | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+
+    expectValidCommand("", {});
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_read |
+                  blobs::StateFlags::open_write,
+              meta.blobState);
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_delete_unittest.cpp b/command/test/hoth_command_delete_unittest.cpp
new file mode 100644
index 0000000..5af5d49
--- /dev/null
+++ b/command/test/hoth_command_delete_unittest.cpp
@@ -0,0 +1,32 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+class HothCommandDeleteTest : public HothCommandTest
+{};
+
+TEST_F(HothCommandDeleteTest, VerifyHothDeleteFails)
+{
+    // The hoth command handler does not support delete.
+
+    EXPECT_FALSE(hvn.deleteBlob(legacyPath));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_open_unittest.cpp b/command/test/hoth_command_open_unittest.cpp
new file mode 100644
index 0000000..4420b9a
--- /dev/null
+++ b/command/test/hoth_command_open_unittest.cpp
@@ -0,0 +1,96 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothCommandOpenTest : public HothCommandTest
+{};
+
+TEST_F(HothCommandOpenTest, OpenWithBadFlagsFails)
+{
+    // Hoth command handler open requires both read & write set.
+
+    EXPECT_FALSE(hvn.open(session_, blobs::OpenFlags::read, legacyPath));
+}
+
+TEST_F(HothCommandOpenTest, OpenWithNoHothd)
+{
+    // Hoth command handler open without a backing hoth daemon present.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(false));
+    EXPECT_FALSE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+}
+
+TEST_F(HothCommandOpenTest, OpenEverythingSucceeds)
+{
+    // Hoth command handler open with everything correct.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+}
+
+TEST_F(HothCommandOpenTest, OpenEleventhSessionFails)
+{
+    // Hoth command handler only allows ten open sessions, verifies the 11th
+    // fails.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(dbus, pingHothd(std::string_view(name)))
+        .WillRepeatedly(Return(true));
+    size_t sessId = 0;
+
+    for (int i = 0; i < hvn.maxSessions(); i++)
+    {
+        EXPECT_TRUE(hvn.open(sessId++, hvn.requiredFlags(), legacyPath));
+    }
+
+    for (int i = 0; i < hvn.maxSessions() - 3; i++)
+    {
+        EXPECT_TRUE(hvn.open(sessId++, hvn.requiredFlags(), namedPath));
+    }
+
+    EXPECT_FALSE(hvn.open(sessId++, hvn.requiredFlags(), legacyPath));
+
+    for (int i = hvn.maxSessions() - 3; i < hvn.maxSessions(); i++)
+    {
+        EXPECT_TRUE(hvn.open(sessId++, hvn.requiredFlags(), namedPath));
+    }
+
+    EXPECT_FALSE(hvn.open(sessId++, hvn.requiredFlags(), namedPath));
+}
+
+TEST_F(HothCommandOpenTest, CannotOpenSameSessionTwice)
+{
+    // Verify the hoth command handler won't let you open the same session
+    // twice.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_read_unittest.cpp b/command/test/hoth_command_read_unittest.cpp
new file mode 100644
index 0000000..bb9c2b7
--- /dev/null
+++ b/command/test/hoth_command_read_unittest.cpp
@@ -0,0 +1,122 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <ipmid/handler.hpp>
+
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::ElementsAre;
+using ::testing::IsEmpty;
+using ::testing::Return;
+
+namespace ipmi_hoth
+{
+
+class HothCommandReadTest : public HothCommandTest
+{
+  protected:
+    const uint32_t testOffset_ = 0;
+    const std::vector<uint8_t> testData_ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    void openAndWriteTestData()
+    {
+        EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+            .WillOnce(Return(true));
+        EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+        EXPECT_TRUE(hvn.write(session_, testOffset_, testData_));
+    }
+};
+
+TEST_F(HothCommandReadTest, InvalidSessionReadIsRejected)
+{
+    // Verify that read checks for a valid session, returns empty buffer for
+    // failed check.
+
+    openAndWriteTestData();
+
+    uint16_t wrongSession = session_ + 1;
+    EXPECT_THROW(hvn.read(wrongSession, testOffset_, testData_.size()),
+                 ipmi::HandlerCompletion);
+}
+
+TEST_F(HothCommandReadTest, ReadOffsetBeyondBufferSizeReturnsEmpty)
+{
+    // Verify that read with offset beyond buffer size returns empty buffer.
+
+    openAndWriteTestData();
+
+    uint32_t offsetBeyondBuffer = testData_.size();
+    EXPECT_THAT(hvn.read(session_, offsetBeyondBuffer, testData_.size()),
+                IsEmpty());
+}
+
+TEST_F(HothCommandReadTest, ReadFullWrittenData)
+{
+    // Verify that the read successfully reads back the written data.
+
+    openAndWriteTestData();
+
+    EXPECT_EQ(testData_, hvn.read(session_, testOffset_, testData_.size()));
+}
+
+TEST_F(HothCommandReadTest, ReadWrittenDataAtOffset)
+{
+    // Verify that the read with offset returns the expected data.
+
+    openAndWriteTestData();
+
+    EXPECT_EQ(testData_, hvn.read(session_, testOffset_, testData_.size()));
+
+    // Try reading the written data byte by byte at each offset
+    for (size_t i = 0; i < testData_.size(); ++i)
+    {
+        EXPECT_THAT(hvn.read(session_, i, 1), ElementsAre(testData_[i]));
+    }
+}
+
+TEST_F(HothCommandReadTest, ReadFullWrittenDataWithBiggerRequestedSize)
+{
+    // Verify that read with requested size bigger than the written data will
+    // return a response buffer up to the end of the written buffer.
+
+    openAndWriteTestData();
+
+    uint32_t requestedSizeBeyondBuffer = testData_.size() + 1;
+    EXPECT_EQ(testData_,
+              hvn.read(session_, testOffset_, requestedSizeBeyondBuffer));
+}
+
+TEST_F(HothCommandReadTest, ReadWrittenDataAtOffsetWithBiggerRequestedSize)
+{
+    // Verify that read with requested size bigger than the written data at an
+    // offset will return a response buffer up to the end of the written buffer.
+
+    openAndWriteTestData();
+
+    uint32_t newOffset = testData_.size() / 2;
+    uint32_t requestedSizeBeyondBuffer = testData_.size() + 1;
+    std::vector<uint8_t> expectedData =
+        std::vector<uint8_t>(testData_.begin() + newOffset, testData_.end());
+
+    EXPECT_EQ(expectedData,
+              hvn.read(session_, newOffset, requestedSizeBeyondBuffer));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_sessionstat_unittest.cpp b/command/test/hoth_command_sessionstat_unittest.cpp
new file mode 100644
index 0000000..7f6876f
--- /dev/null
+++ b/command/test/hoth_command_sessionstat_unittest.cpp
@@ -0,0 +1,78 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothCommandSessionStatTest : public HothCommandTest
+{
+  protected:
+    blobs::BlobMeta meta_;
+    // Initialize expected_meta_ with empty members
+    blobs::BlobMeta expected_meta_ = {};
+};
+
+TEST_F(HothCommandSessionStatTest, InvalidSessionStatIsRejected)
+{
+    // Verify the hoth command handler checks for a valid session.
+
+    EXPECT_FALSE(hvn.stat(session_, &meta_));
+}
+
+TEST_F(HothCommandSessionStatTest, SessionStatAlwaysInitialReadAndWrite)
+{
+    // Verify the session stat returns the information for a session.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    expected_meta_.blobState =
+        blobs::StateFlags::open_read | blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothCommandSessionStatTest, AfterWriteMetadataLengthMatches)
+{
+    // Verify that after writes, the length returned matches.
+
+    std::vector<uint8_t> data = {0x01};
+    EXPECT_EQ(1, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.write(session_, (hvn.maxBufferSize() - 1), data));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    // We wrote one byte to the last index, making the length the buffer size.
+    expected_meta_.size = hvn.maxBufferSize();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_read | blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_unittest.cpp b/command/test/hoth_command_unittest.cpp
new file mode 100644
index 0000000..97e1bf3
--- /dev/null
+++ b/command/test/hoth_command_unittest.cpp
@@ -0,0 +1,84 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::Return;
+using ::testing::UnorderedElementsAreArray;
+
+namespace ipmi_hoth
+{
+
+class HothCommandBasicTest : public HothCommandTest
+{};
+
+TEST_F(HothCommandBasicTest, PathToHothId)
+{
+    EXPECT_EQ("", hvn.pathToHothId("/dev/hoth/command_passthru"));
+    EXPECT_EQ("hoth0", hvn.pathToHothId("/dev/hoth/hoth0/command_passthru"));
+    EXPECT_EQ("", hvn.pathToHothId("/dev/hoth//command_passthru"));
+    EXPECT_EQ("", hvn.pathToHothId("/dev/hoth////command_passthru"));
+}
+
+TEST_F(HothCommandBasicTest, HothIdToPath)
+{
+    EXPECT_EQ("/dev/hoth/command_passthru", hvn.hothIdToPath(""));
+    EXPECT_EQ("/dev/hoth/hoth0/command_passthru", hvn.hothIdToPath("hoth0"));
+}
+
+TEST_F(HothCommandBasicTest, CanHandleBlobChecksNameInvalid)
+{
+    // Verify canHandleBlob checks and returns false on an invalid name.
+
+    EXPECT_FALSE(hvn.canHandleBlob("asdf"));
+    EXPECT_FALSE(hvn.canHandleBlob("dev/hoth/command_passthru"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/command_passthru2"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/hoth0/t/command_passthru"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/firmware_update"));
+}
+
+TEST_F(HothCommandBasicTest, CanHandleBlobChecksNameValid)
+{
+    // Verify canHandleBlob checks and returns true on the valid name.
+
+    EXPECT_TRUE(hvn.canHandleBlob("/dev/hoth/command_passthru"));
+    EXPECT_TRUE(hvn.canHandleBlob("/dev/hoth/hoth0/command_passthru"));
+}
+
+TEST_F(HothCommandBasicTest, VerifyBehaviorOfBlobIds)
+{
+    // Verify the correct BlobIds is returned from the hoth command handler.
+    internal::Dbus::SubTreeMapping mapping = {
+        {"/xyz/openbmc_project/Control", {}},
+        {"/xyz/openbmc_project/Control/Hoth2nologue", {}},
+        {"/xyz/openbmc_project/Control/Hoth/nologue/2", {}},
+        {"/xyz/openbmc_project/Control/Hoth", {}},
+        {"/xyz/openbmc_project/Control/Hoth/hoth0", {}},
+        {"/xyz/openbmc_project/Control/Hoth/hoth1", {}},
+    };
+    EXPECT_CALL(dbus, getHothdMapping()).WillOnce(Return(mapping));
+    std::vector<std::string> expected = {
+        "/dev/hoth/command_passthru",
+        "/dev/hoth/hoth0/command_passthru",
+        "/dev/hoth/hoth1/command_passthru",
+    };
+    EXPECT_THAT(hvn.getBlobIds(), UnorderedElementsAreArray(expected));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_unittest.hpp b/command/test/hoth_command_unittest.hpp
new file mode 100644
index 0000000..bf64731
--- /dev/null
+++ b/command/test/hoth_command_unittest.hpp
@@ -0,0 +1,48 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_command_mock.hpp"
+#include "hoth_command.hpp"
+
+#include <stdplus/util/string.hpp>
+
+#include <cstdint>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+class HothCommandTest : public ::testing::Test
+{
+  protected:
+    explicit HothCommandTest() : hvn(&dbus) {}
+
+    // dbus mock object
+    testing::StrictMock<internal::DbusCommandMock> dbus;
+
+    HothCommandBlobHandler hvn;
+
+    const uint16_t session_ = 0;
+    const std::string legacyPath = stdplus::util::strCat(
+        HothCommandBlobHandler::hothPathPrefix, hvn.pathSuffix());
+    const std::string name = "hoth0";
+    const std::string namedPath = stdplus::util::strCat(
+        HothCommandBlobHandler::hothPathPrefix, name, "/", hvn.pathSuffix());
+};
+
+} // namespace ipmi_hoth
diff --git a/command/test/hoth_command_write_unittest.cpp b/command/test/hoth_command_write_unittest.cpp
new file mode 100644
index 0000000..702e633
--- /dev/null
+++ b/command/test/hoth_command_write_unittest.cpp
@@ -0,0 +1,133 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_command_unittest.hpp"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothCommandWriteTest : public HothCommandTest
+{};
+
+TEST_F(HothCommandWriteTest, InvalidSessionWriteIsRejected)
+{
+    // Verify the hoth command handler checks for a valid session.
+
+    std::vector<uint8_t> data = {0x1, 0x2};
+
+    EXPECT_FALSE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothCommandWriteTest, WritingTooMuchByOneByteFails)
+{
+    // Test the edge case of writing 1 byte too much with an offset of 0.
+    // writing 1025 at offset 0 is invalid.
+
+    int bytes = hvn.maxBufferSize() + 1;
+    std::vector<uint8_t> data(0x11);
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothCommandWriteTest, WritingTooMuchByOffsetOfOne)
+{
+    // Test the edge case of writing 1024 bytes (which is fine) but at the
+    // offset 1, which makes it go over by 1 byte.
+    // writing 1024 at offset 1 is invalid.
+
+    int bytes = hvn.maxBufferSize();
+    std::vector<uint8_t> data(0x11);
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    // offset of 1.
+    EXPECT_FALSE(hvn.write(session_, 1, data));
+}
+
+TEST_F(HothCommandWriteTest, WritingOneByteBeyondEndFromOffsetFails)
+{
+    // Test the edge case of writing to the last byte offset but trying to
+    // write two bytes.
+    // writing 2 bytes at 1023 is invalid.
+
+    std::vector<uint8_t> data = {0x01, 0x02};
+    ASSERT_EQ(2, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, (hvn.maxBufferSize() - 1), data));
+}
+
+TEST_F(HothCommandWriteTest, WritingOneByteAtOffsetBeyondEndFails)
+{
+    // Test the edge case of writing one byte but exactly one byte beyond the
+    // buffer.
+    // writing 1 byte at 1024 is invalid.
+
+    std::vector<uint8_t> data = {0x01};
+    ASSERT_EQ(1, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, hvn.maxBufferSize(), data));
+}
+
+TEST_F(HothCommandWriteTest, WritingFullBufferAtOffsetZeroSucceeds)
+{
+    // Test the case where you write the full buffer length at once to the 0th
+    // offset.
+
+    int bytes = hvn.maxBufferSize();
+    std::vector<uint8_t> data = {0x01};
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothCommandWriteTest, WritingOneByteToTheLastOffsetSucceeds)
+{
+    // Test the case where you write the last byte.
+
+    std::vector<uint8_t> data = {0x01};
+    ASSERT_EQ(1, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.write(session_, (hvn.maxBufferSize() - 1), data));
+}
+
+} // namespace ipmi_hoth
diff --git a/command/test/meson.build b/command/test/meson.build
new file mode 100644
index 0000000..2adea16
--- /dev/null
+++ b/command/test/meson.build
@@ -0,0 +1,20 @@
+tests = [
+  'hoth_command_unittest',
+  'hoth_command_close_unittest',
+  'hoth_command_commit_unittest',
+  'hoth_command_delete_unittest',
+  'hoth_command_open_unittest',
+  'hoth_command_read_unittest',
+  'hoth_command_sessionstat_unittest',
+  'hoth_command_write_unittest',
+]
+
+foreach t : tests
+  test(
+    t,
+    executable(
+      t.underscorify(),
+      t + '.cpp',
+      implicit_include_directories: false,
+      dependencies: [hothcommand_dep, test_dep]))
+endforeach
diff --git a/dbus.cpp b/dbus.cpp
new file mode 100644
index 0000000..3a38ac8
--- /dev/null
+++ b/dbus.cpp
@@ -0,0 +1,98 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus.hpp"
+
+#include "dbus_impl.hpp"
+
+#include <ipmid/api.h>
+
+#include <sdbusplus/exception.hpp>
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+DbusImpl::DbusImpl() : bus(ipmid_get_sd_bus_connection()) {}
+
+Dbus::SubTreeMapping DbusImpl::getHothdMapping()
+{
+    auto req =
+        bus.new_method_call("xyz.openbmc_project.ObjectMapper",
+                            "/xyz/openbmc_project/object_mapper",
+                            "xyz.openbmc_project.ObjectMapper", "GetSubTree");
+    req.append("/");
+    req.append(0);
+    req.append(std::vector<std::string>({"xyz.openbmc_project.Control.Hoth"}));
+    auto rsp = bus.call(req, kTimeout);
+    SubTreeMapping mapping;
+    rsp.read(mapping);
+    return mapping;
+}
+
+std::string hothIdToSvc(std::string_view hothId)
+{
+    std::string svc = "xyz.openbmc_project.Control.Hoth";
+    if (!hothId.empty())
+    {
+        svc += ".";
+        svc += hothId;
+    }
+    return svc;
+}
+
+bool DbusImpl::pingHothd(std::string_view hothId)
+{
+    try
+    {
+        auto req =
+            bus.new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus",
+                                "org.freedesktop.DBus", "GetNameOwner");
+        req.append(hothIdToSvc(hothId));
+        bus.call(req, kTimeout);
+        return true;
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        return false;
+    }
+}
+
+sdbusplus::message::message DbusImpl::newHothdCall(
+    std::string_view hothId, const char* intf, const char* method)
+{
+    std::string svc = hothIdToSvc(hothId);
+    std::string obj = "/xyz/openbmc_project/Control/Hoth";
+    if (!hothId.empty())
+    {
+        obj += "/";
+        obj += hothId;
+    }
+    return bus.new_method_call(svc.c_str(), obj.c_str(), intf, method);
+}
+
+sdbusplus::message::message
+    DbusImpl::newHothdCall(std::string_view hothId, const char* method)
+{
+    return newHothdCall(hothId, "xyz.openbmc_project.Control.Hoth", method);
+}
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/dbus.hpp b/dbus.hpp
new file mode 100644
index 0000000..b01ad1d
--- /dev/null
+++ b/dbus.hpp
@@ -0,0 +1,74 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <sdbusplus/sdbus.hpp>
+#include <sdbusplus/slot.hpp>
+#include <stdplus/cancel.hpp>
+
+#include <chrono>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+struct BusCall : public stdplus::Cancelable
+{
+    sdbusplus::slot::slot slot;
+    explicit BusCall(sdbusplus::slot::slot&& slot) : slot(std::move(slot)) {}
+    void cancel() noexcept override
+    {
+        delete this;
+    }
+};
+
+/** @class Dbus
+ *  @brief Overridable D-Bus interface for generic handler
+ */
+class Dbus
+{
+  public:
+    /** An arbitrary timeout to ensure that clients don't linger forever */
+    static constexpr auto asyncCallTimeout = std::chrono::minutes(3);
+
+    using SubTreeMapping = std::unordered_map<
+        std::string, std::unordered_map<std::string, std::vector<std::string>>>;
+
+    virtual ~Dbus() = default;
+
+    /** @brief Gets the D-Bus mapper information for all hoth instances
+     *
+     *  @throw exception::SdBusError - All dbus exceptions will be thrown
+     *                                 with this exception
+     *  @return The mapping of object paths and services to hoth interfaces.
+     */
+    virtual SubTreeMapping getHothdMapping() = 0;
+
+    /** @brief Determines if a hothd instance is running on the system
+     *
+     *  @return True if the hoth is running, false for other errors.
+     */
+    virtual bool pingHothd(std::string_view hothId) = 0;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/dbus_impl.hpp b/dbus_impl.hpp
new file mode 100644
index 0000000..022c0b3
--- /dev/null
+++ b/dbus_impl.hpp
@@ -0,0 +1,73 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus.hpp"
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/message.hpp>
+
+#include <chrono>
+#include <string_view>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class DbusImpl
+ *  @brief D-Bus concrete implementation
+ *  @details Pass through all calls to the default D-Bus instance
+ */
+class DbusImpl : public virtual Dbus
+{
+  public:
+    /** @brief Timeout suitable for responding to IPMI queries before
+     *         the sending mechanism like kcsbridge issues a retry.
+     */
+    static constexpr auto kTimeout = std::chrono::seconds(4);
+
+    DbusImpl();
+
+    SubTreeMapping getHothdMapping() override;
+    bool pingHothd(std::string_view hothId) override;
+
+  protected:
+    /** @brief Helper for building a message targeting a hoth daemon
+     *
+     *  @param[in] hothId - The identifier of the hoth daemon
+     *  @param[in] intf    - The name of the D-Bus interface being called
+     *  @param[in] method  - The D-Bus method being called on the interface
+     *  @return The empty message which can be sent.
+     */
+    sdbusplus::message::message newHothdCall(
+        std::string_view hothId, const char* intf, const char* method);
+
+    /** @brief Helper for building a message targeting a hoth daemon
+     *         assuming the call is for the hoth interface.
+     *
+     *  @param[in] hothId - The identifier of the hoth daemon
+     *  @param[in] method  - The D-Bus method being called on the interface
+     *  @return The empty message which can be sent.
+     */
+    sdbusplus::message::message newHothdCall(std::string_view hothId,
+                                             const char* method);
+
+    sdbusplus::bus::bus bus;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/hoth.cpp b/hoth.cpp
new file mode 100644
index 0000000..d3918e7
--- /dev/null
+++ b/hoth.cpp
@@ -0,0 +1,267 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth.hpp"
+
+#include <ipmid/api-types.hpp>
+#include <ipmid/handler.hpp>
+#include <stdplus/util/string.hpp>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+
+std::string_view HothBlobHandler::pathToHothId(std::string_view path)
+{
+    if (path.starts_with(hothPathPrefix) && path.ends_with(pathSuffix()))
+    {
+        auto id = path.substr(
+            hothPathPrefix.size(),
+            path.size() - pathSuffix().size() - hothPathPrefix.size());
+        auto count = std::count(id.begin(), id.end(), '/');
+
+        // There can only be prefix + pathSuffix or
+        // prefix + id/pathSuffix.
+        // prefix already has one `/`
+        if (count == 1)
+        {
+            return id.substr(0, id.size() - 1);
+        }
+        else if (count > 1)
+        {
+            return "";
+        }
+
+        return id;
+    }
+    return "";
+}
+
+std::string HothBlobHandler::hothIdToPath(std::string_view hothId)
+{
+    if (hothId.empty())
+    {
+        return stdplus::util::strCat(hothPathPrefix, pathSuffix());
+    }
+    return stdplus::util::strCat(hothPathPrefix, hothId, "/", pathSuffix());
+}
+
+HothBlob* HothBlobHandler::getSession(uint16_t id)
+{
+    auto search = sessions.find(id);
+    if (search == sessions.end())
+    {
+        return nullptr;
+    }
+
+    /* Not thread-safe, however, the blob handler deliberately assumes serial
+     * execution. */
+    return search->second.get();
+}
+
+std::optional<uint16_t> HothBlobHandler::getOnlySession(std::string_view hothId)
+{
+    /* This method is only valid if we only allow 1 session */
+    if (maxSessions() != 1)
+    {
+        return std::nullopt;
+    }
+
+    for (auto& session : pathSessions[std::string(hothId)])
+    {
+        return session;
+    }
+
+    return std::nullopt;
+}
+
+bool HothBlobHandler::canHandleBlob(const std::string& path)
+{
+    if (path.starts_with(hothPathPrefix) && path.ends_with(pathSuffix()))
+    {
+        // There can only be hothPathPrefix + pathSuffix or
+        // hothPathPrefix + id/pathSuffix
+        // hothPathPrefix already has one `/`
+        return std::count(path.begin() + hothPathPrefix.size(),
+                          path.end() - pathSuffix().size(), '/') <= 1;
+    }
+    return false;
+}
+
+std::vector<std::string> HothBlobHandler::getBlobIds()
+{
+    std::vector<std::string> ret;
+    for (const auto& obj : dbus().getHothdMapping())
+    {
+        std::string_view objView = obj.first;
+        std::string_view objPrefix = "/xyz/openbmc_project/Control/Hoth";
+        if (objView.substr(0, objPrefix.size()) != objPrefix)
+        {
+            continue;
+        }
+        objView.remove_prefix(objPrefix.size());
+        if (objView.empty())
+        {
+            ret.push_back(hothIdToPath(""));
+            continue;
+        }
+        if (objView[0] != '/')
+        {
+            continue;
+        }
+        objView.remove_prefix(1);
+        auto sep = objView.find('/');
+        if (sep != std::string_view::npos)
+        {
+            continue;
+        }
+        ret.push_back(hothIdToPath(objView));
+    }
+    return ret;
+}
+
+bool HothBlobHandler::deleteBlob(const std::string&)
+{
+    /* Hoth blob handler does not support a blob delete. */
+    return false;
+}
+
+bool HothBlobHandler::open(uint16_t session, uint16_t flags,
+                           const std::string& path)
+{
+    /* We require both flags set. */
+    if ((flags & requiredFlags()) != requiredFlags())
+    {
+        /* Both flags not set. */
+        return false;
+    }
+
+    auto findSess = sessions.find(session);
+    if (findSess != sessions.end())
+    {
+        /* This session is already active. */
+        return false;
+    }
+
+    auto hothId = std::string(pathToHothId(path));
+    auto pathSession = pathSessions.find(hothId);
+    if (pathSession != pathSessions.end() &&
+        pathSession->second.size() >= maxSessions())
+    {
+        return false;
+    }
+
+    // Prevent host from adding lots of bad entries to the table by verifying
+    // the hoth exists.
+    if (pathSession == pathSessions.end() && !dbus().pingHothd(hothId))
+    {
+        return false;
+    }
+
+    pathSessions[hothId].emplace(session);
+    sessions.emplace(session,
+                     std::make_unique<HothBlob>(session, std::move(hothId),
+                                                flags, maxBufferSize()));
+    return true;
+}
+
+std::vector<uint8_t> HothBlobHandler::read(uint16_t session, uint32_t offset,
+                                           uint32_t requestedSize)
+{
+    HothBlob* sess = getSession(session);
+    if (!sess || !(sess->state & blobs::StateFlags::open_read) ||
+        offset > sess->buffer.size())
+    {
+        throw ipmi::HandlerCompletion(ipmi::ccUnspecifiedError);
+    }
+
+    if (sess->buffer.size() > offset)
+    {
+        std::vector<uint8_t> ret(
+            std::min<size_t>(requestedSize, sess->buffer.size() - offset));
+        std::memcpy(ret.data(), sess->buffer.data() + offset, ret.size());
+        return ret;
+    }
+    return {};
+}
+
+bool HothBlobHandler::write(uint16_t session, uint32_t offset,
+                            const std::vector<uint8_t>& data)
+{
+    uint32_t newBufferSize = data.size() + offset;
+    HothBlob* sess = getSession(session);
+    if (!sess || !(sess->state & blobs::StateFlags::open_write) ||
+        newBufferSize > maxBufferSize())
+    {
+        return false;
+    }
+
+    /* Resize the buffer if what we're writing will go over the size */
+    if (newBufferSize > sess->buffer.size())
+    {
+        sess->buffer.resize(newBufferSize);
+        sess->state &= ~blobs::StateFlags::committed;
+    }
+
+    /* Clear the comitted bit if our data isn't identical to existing data */
+    if (std::memcmp(sess->buffer.data() + offset, data.data(), data.size()))
+    {
+        sess->state &= ~blobs::StateFlags::committed;
+    }
+    if (!data.empty())
+    {
+        std::memcpy(sess->buffer.data() + offset, data.data(), data.size());
+    }
+    return true;
+}
+
+bool HothBlobHandler::writeMeta(uint16_t, uint32_t, const std::vector<uint8_t>&)
+{
+    /* Hoth blob handler does not support meta write. */
+    return false;
+}
+
+bool HothBlobHandler::close(uint16_t session)
+{
+    auto session_it = sessions.find(session);
+    if (session_it == sessions.end())
+    {
+        return false;
+    }
+
+    auto path_it = pathSessions.find(session_it->second->hothId);
+    path_it->second.erase(session);
+    if (path_it->second.empty())
+    {
+        pathSessions.erase(path_it);
+    }
+
+    sessions.erase(session_it);
+    return true;
+}
+
+bool HothBlobHandler::expire(uint16_t session)
+{
+    return close(session);
+}
+
+} // namespace ipmi_hoth
diff --git a/hoth.hpp b/hoth.hpp
new file mode 100644
index 0000000..37dac70
--- /dev/null
+++ b/hoth.hpp
@@ -0,0 +1,128 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+#include <stdplus/cancel.hpp>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace ipmi_hoth
+{
+
+struct HothBlob
+{
+    HothBlob(uint16_t id, std::string&& hothId, uint16_t flags,
+             uint32_t maxBufferSize) :
+        sessionId(id), hothId(std::move(hothId)), state(0)
+    {
+        if (flags & blobs::OpenFlags::read)
+        {
+            state |= blobs::StateFlags::open_read;
+        }
+        if (flags & blobs::OpenFlags::write)
+        {
+            state |= blobs::StateFlags::open_write;
+        }
+
+        /* Pre-allocate the buffer.capacity() with maxBufferSize */
+        buffer.reserve(maxBufferSize);
+    }
+    ~HothBlob()
+    {
+        /* We want to deliberately wipe the buffer to avoid leaking any
+         * sensitive ProdID secrets.
+         */
+        buffer.assign(buffer.capacity(), 0);
+    }
+
+    /* The blob handler session id. */
+    uint16_t sessionId;
+
+    /* The identifier for the hoth */
+    std::string hothId;
+
+    /* The current state. */
+    uint16_t state;
+
+    /* The staging buffer. */
+    std::vector<uint8_t> buffer;
+
+    /* Outstanding async operation */
+    stdplus::Cancel outstanding;
+};
+
+class HothBlobHandler : public blobs::GenericBlobInterface
+{
+  public:
+    static constexpr std::string_view hothPathPrefix = "/dev/hoth/";
+
+    bool canHandleBlob(const std::string& path) override;
+    std::vector<std::string> getBlobIds() override;
+    bool deleteBlob(const std::string& path) override;
+    virtual bool stat(const std::string& path, blobs::BlobMeta* meta) = 0;
+    bool open(uint16_t session, uint16_t flags,
+              const std::string& path) override;
+    std::vector<uint8_t> read(uint16_t session, uint32_t offset,
+                              uint32_t requestedSize) override;
+    bool write(uint16_t session, uint32_t offset,
+               const std::vector<uint8_t>& data) override;
+    bool writeMeta(uint16_t session, uint32_t offset,
+                   const std::vector<uint8_t>& data) override;
+    virtual bool commit(uint16_t session, const std::vector<uint8_t>& data) = 0;
+    bool close(uint16_t session) override;
+    virtual bool stat(uint16_t session, blobs::BlobMeta* meta) = 0;
+    bool expire(uint16_t session) override;
+
+    virtual internal::Dbus& dbus() = 0;
+    virtual std::string_view pathSuffix() const = 0;
+    virtual uint16_t requiredFlags() const = 0;
+    virtual uint16_t maxSessions() const = 0;
+    virtual uint32_t maxBufferSize() const = 0;
+
+    /** @brief Takes a valid hoth blob path and turns it into a hoth id
+     *
+     *  @param[in] path - Hoth blob path to parse
+     *  @return The hoth id represented by the path
+     */
+    std::string_view pathToHothId(std::string_view path);
+
+    /** @brief Takes a hoth id and turns it into a fully qualified path for
+     *         the current hoth handler.
+     *
+     *  @param[in] hothId - The hoth id
+     *  @return The fully qualified blob path
+     */
+    std::string hothIdToPath(std::string_view hothId);
+
+  protected:
+    HothBlob* getSession(uint16_t id);
+    std::optional<uint16_t> getOnlySession(std::string_view hothId);
+
+  private:
+    std::unordered_map<std::string, std::unordered_set<uint16_t>> pathSessions;
+    std::unordered_map<uint16_t, std::unique_ptr<HothBlob>> sessions;
+};
+
+} // namespace ipmi_hoth
diff --git a/meson.build b/meson.build
new file mode 100644
index 0000000..cdab3c1
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,54 @@
+project(
+  'hoth-ipmi-blobs',
+  'cpp',
+  version: '0.1',
+  meson_version: '>=1.1.1',
+  default_options: [
+    'b_lundef=false',
+    'cpp_std=c++23',
+    'warning_level=3',
+    'werror=true',
+  ])
+
+sdbusplus_dep = dependency('sdbusplus', fallback: ['sdbusplus','sdbusplus_dep'])
+stdplus_dep = dependency('stdplus', fallback: ['stdplus','stdplus_dep'])
+ipmi_blob_dep = dependency('phosphor-ipmi-blobs')
+phosphor_logging_dep = dependency('phosphor-logging')
+
+meson.get_compiler('cpp').has_header_symbol(
+  'ipmid/api.h',
+  'ipmid_get_sd_bus_connection')
+
+hothblob_pre = declare_dependency(
+  include_directories: include_directories('.'),
+  dependencies: [
+    ipmi_blob_dep,
+    sdbusplus_dep,
+    stdplus_dep,
+  ])
+
+hothblob_lib = library(
+  'hothblob',
+  'dbus.cpp',
+  'hoth.cpp',
+  implicit_include_directories: false,
+  dependencies: hothblob_pre,
+  version: meson.project_version(),
+  install: true)
+
+hothblob_dep = declare_dependency(
+  link_with: hothblob_lib,
+  dependencies: hothblob_pre)
+
+if not get_option('tests').disabled()
+  subdir('test')
+endif
+
+subdir('command')
+if get_option('skm')
+  subdir('skmhss')
+endif
+
+if get_option('hoth-inband-update').allowed()
+  subdir('update')
+endif
diff --git a/meson_options.txt b/meson_options.txt
new file mode 100644
index 0000000..86a8705
--- /dev/null
+++ b/meson_options.txt
@@ -0,0 +1,4 @@
+option('tests', type: 'feature', description: 'Build tests')
+option('skm', type: 'boolean', description: 'Support SKM')
+option('skmhss-hothid-config', type: 'string', value: '/usr/share/hoth-ipmi-blobs/hothid_basepaths.json', description: 'Path to basepath to hothId mapping Json config')
+option('hoth-inband-update', type: 'feature', description: 'Support hoth firmware update via IPMI')
diff --git a/skmhss/google3/g_ec_commands.h b/skmhss/google3/g_ec_commands.h
new file mode 100644
index 0000000..9a93e3c
--- /dev/null
+++ b/skmhss/google3/g_ec_commands.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SECURITY_CRYPTA_COMMANDS_CHROMIUMOS_G_EC_COMMANDS_H_
+#define SECURITY_CRYPTA_COMMANDS_CHROMIUMOS_G_EC_COMMANDS_H_
+
+#include <stdint.h>
+
+#define G_EC_HOST_REQUEST_VERSION 3
+#define G_EC_HOST_RESPONSE_VERSION 3
+
+#define G_EC_CMD_BOARD_SPECIFIC_BASE 0x3E00
+
+/* Given the private host command offset, calculate the true private host
+ * command value.
+ */
+#define G_EC_PRIVATE_HOST_COMMAND_VALUE(command)                               \
+    (G_EC_CMD_BOARD_SPECIFIC_BASE + (command))
+
+/* Version 3 request from host */
+typedef struct
+{
+    /* Structure version (=3)
+     *
+     * EC will return EC_RES_INVALID_HEADER if it receives a header with a
+     * version it doesn't know how to parse.
+     */
+    uint8_t struct_version;
+
+    /* Checksum of request and data; sum of all bytes including checksum should
+     * total to 0.
+     */
+    uint8_t checksum;
+
+    /* Command code */
+    uint16_t command;
+
+    /* Command version */
+    uint8_t command_version;
+
+    /* Unused byte in current protocol version; set to 0 */
+    uint8_t reserved;
+
+    /* Length of data which follows this header */
+    uint16_t data_len;
+} __attribute__((packed)) g_ec_host_request;
+
+/* Version 3 response from EC */
+typedef struct
+{
+    /* Structure version (=3) */
+    uint8_t struct_version;
+
+    /* Checksum of response and data; sum of all bytes including checksum should
+     * total to 0.
+     */
+    uint8_t checksum;
+
+    /* Result code (EC_RES_*) */
+    uint16_t result;
+
+    /* Length of data which follows this header */
+    uint16_t data_len;
+
+    /* Unused bytes in current protocol version; set to 0 */
+    uint16_t reserved;
+} __attribute__((packed)) g_ec_host_response;
+
+#endif // SECURITY_CRYPTA_COMMANDS_CHROMIUMOS_G_EC_COMMANDS_H_
diff --git a/skmhss/google3/host_commands.h b/skmhss/google3/host_commands.h
new file mode 100644
index 0000000..087f71c
--- /dev/null
+++ b/skmhss/google3/host_commands.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __PRIVATE_CR51_INCLUDE_CR51_HOST_COMMANDS_H
+#define __PRIVATE_CR51_INCLUDE_CR51_HOST_COMMANDS_H
+
+#include <stdint.h>
+
+/* Read/Write/Erase Hoth's copy of SKM HSS persisted to gNVRAM. */
+#define EC_PRV_CMD_HOTH_SKM_HSS 0x0015
+
+#define SKM_HSS_STRUCT_SIZE 64
+enum skm_hss_op
+{
+    SKM_HSS_READ = 0,
+    SKM_HSS_WRITE = 1,
+    SKM_HSS_DELETE = 2,
+};
+
+/* Serves as the response to SKM_HSS_READ as well as payload to SKM_HSS_WRITE.
+ */
+struct ec_payload_skm_hss
+{
+    uint8_t data[SKM_HSS_STRUCT_SIZE];
+} __attribute__((packed));
+
+struct ec_request_skm_hss
+{
+    /* The operation is one of skm_hss_op. */
+    uint32_t operation;
+    /* Choose which (0-3) HSS to operate on. */
+    uint32_t slot;
+    struct ec_payload_skm_hss payload;
+} __attribute__((packed));
+
+#endif /* __PRIVATE_CR51_INCLUDE_CR51_HOST_COMMANDS_H */
diff --git a/skmhss/hoth_skmhss.cpp b/skmhss/hoth_skmhss.cpp
new file mode 100644
index 0000000..fc33250
--- /dev/null
+++ b/skmhss/hoth_skmhss.cpp
@@ -0,0 +1,464 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss.hpp"
+
+#include "config.hpp"
+
+#include <fmt/format.h>
+#include <google3/host_commands.h>
+
+#include <blobs-ipmid/blobs.hpp>
+#include <nlohmann/json.hpp>
+#include <phosphor-logging/log.hpp>
+#include <stdplus/cancel.hpp>
+#include <xyz/openbmc_project/Control/Hoth/error.hpp>
+
+#include <algorithm>
+#include <charconv>
+#include <cstring>
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <span>
+#include <string>
+#include <vector>
+
+using phosphor::logging::entry;
+using phosphor::logging::log;
+
+using level = phosphor::logging::level;
+using SdBusError = sdbusplus::exception::SdBusError;
+using CommandFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::CommandFailure;
+using ResponseFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::ResponseFailure;
+using json = nlohmann::json;
+
+namespace ipmi_hoth
+{
+
+namespace internal
+{
+
+/**
+ * @brief: Get baseId from a blob id string
+ * @param blobId: Input blob id which is expected to only contain alphanumerical
+ *                characters and '/'.
+ * @returns: The baseId containing the blobId, stripping all contents from the
+ *           last '/'. If no '/' is present, an empty string is returned.
+ */
+static std::string_view getBaseFromID(std::string_view blobId)
+{
+    return blobId.substr(0, blobId.find_last_of('/') + 1);
+}
+
+/**
+ * @brief: Get the blob identifer under the baseId
+ * @param blobId: Input blob id which is expected to only contain alphanumerical
+ *                characters and '/'.
+ * @returns: The truncated blobId, by deleting the baseId prefix
+ *           in the input blobId.
+ */
+static std::string_view stripBaseFromID(std::string_view blobId)
+{
+    return blobId.substr(blobId.find_last_of('/') + 1);
+}
+
+/**
+ * @brief: Get the slot number from a blob id string
+ * @param blobId: Input blob id which is expected to only contain alphanumerical
+ *                characters and '/'.
+ * @returns: The slot number if the blob id has a tailing integer; otherwise
+ * returns a null pointer;
+ */
+static std::optional<uint32_t> extractSlotFromID(std::string_view blobId)
+{
+    std::string_view pathId = internal::stripBaseFromID(blobId);
+    uint32_t slot;
+    const auto res =
+        std::from_chars(pathId.data(), pathId.data() + pathId.size(), slot);
+
+    if (res.ec != std::errc() || res.ptr != pathId.data() + pathId.size())
+    {
+        return std::nullopt;
+    }
+
+    return slot;
+}
+
+} // namespace internal
+
+void HothSKMHSSBlobHandler::loadHSS()
+{
+    readBasePathConfig();
+    for (auto& [basePath, hothId] : hothIdBasePaths)
+    {
+        slotPopulated[basePath] = {};
+        inits[basePath] = {};
+        dels[basePath] = {};
+        /* Iterate all slots and find valid HSS copies */
+        for (uint32_t slot = 0; slot < maxNumHSSSlot; slot++)
+        {
+            auto& init = inits[basePath][slot];
+            init = readSKMHSSSlot(
+                basePath, slot, hothId,
+                [&](std::span<const uint8_t>) noexcept { init.reset(); });
+        }
+    }
+}
+
+/* read the hothid_basepaths.config and store it in hothIdBasePaths*/
+/**
+ * @brief: Read the hothid_basepaths.config and store it in a bimap.
+ *         It populates basePath <--> hothId mapping
+ * @param :
+ * @returns:
+ */
+void HothSKMHSSBlobHandler::readBasePathConfig()
+{
+    std::ifstream configFile(HOTHID_CONFIG);
+
+    // Check if the config file exists
+    if (configFile.fail())
+    {
+        log<level::ERR>(
+            "config file does not exist, populate map with defaults");
+
+        // There is no config file,
+        // So, populate with default values
+        hothIdBasePaths.insert({"/skm/hss-backup/", ""});
+        return;
+    }
+
+    try
+    {
+        json data = json::parse(configFile);
+        for (const auto& [basePath, hothId] : data.items())
+        {
+            hothIdBasePaths.insert({basePath, hothId});
+        }
+    }
+    catch (json::parse_error& ex)
+    {
+        log<level::ERR>("config parse error at ", entry("ERR_MSG=%d", ex.byte));
+    }
+}
+
+/**
+ * @brief: Get the hothId from a blob id string
+ * @param blobId: Input blob id which is expected to only contain alphanumerical
+ *                characters and '/'.
+ * @returns: The hothId from the map hothIdBasePaths if it exists; otherwise
+ * empty string
+ */
+std::string_view
+    HothSKMHSSBlobHandler::getHothIdFromPath(std::string_view blobId)
+{
+    auto base = internal::getBaseFromID(blobId);
+    auto it = hothIdBasePaths.left.find(static_cast<std::string>(base));
+
+    if (it != hothIdBasePaths.left.end())
+    {
+        return it->second;
+    }
+    return "";
+}
+
+/**
+ * @brief: Get the base path from a hothId string
+ * @param hothId: Input hothId string
+ * @returns: The hothId from the bimap hothIdBasePaths if it exists; otherwise
+ * empty string
+ */
+std::string_view
+    HothSKMHSSBlobHandler::getBaseFromHothId(std::string_view hothId)
+{
+    auto it = hothIdBasePaths.right.find(static_cast<std::string>(hothId));
+    if (it != hothIdBasePaths.right.end())
+    {
+        return it->second;
+    }
+    return "";
+}
+
+stdplus::Cancel HothSKMHSSBlobHandler::readSKMHSSSlot(
+    std::string_view base, uint32_t slot, std::string_view hothId,
+    fu2::unique_function<void(std::span<const uint8_t>)>&& cb)
+{
+    auto req = hothUtil_->readSKMHSS(slot);
+    return dbus_->SendHostCommand(
+        hothId, req,
+        [this, base, slot, cb = std::move(cb)](
+            std::optional<std::vector<uint8_t>> rsp) mutable noexcept {
+            try
+            {
+                auto data = hothUtil_->payloadECResponse(rsp.value());
+                this->slotPopulated[base][slot] =
+                    data.size() == SKM_HSS_STRUCT_SIZE;
+                cb(data);
+                return;
+            }
+            catch (const ResponseFailure& e)
+            {
+                log<level::ERR>("Invalid Hoth response",
+                                entry("ERR_MSG=%s", e.what()));
+            }
+            catch (...)
+            {}
+            cb({});
+        });
+}
+
+bool HothSKMHSSBlobHandler::canHandleBlob(const std::string& path)
+{
+    auto base = internal::getBaseFromID(path);
+    if (hothIdBasePaths.left.find(static_cast<std::string>(base)) ==
+        hothIdBasePaths.left.end())
+    {
+        return false;
+    }
+
+    auto hothId = getHothIdFromPath(path);
+    if (!dbus_->pingHothd(hothId))
+    {
+        return false;
+    }
+
+    /* The HSS path is expected to be "/skm/hss-backup/{0,1,2,...}" */
+    std::optional<uint32_t> slotPtr = internal::extractSlotFromID(path);
+    if (!slotPtr)
+    {
+        return false;
+    }
+    return *slotPtr < maxNumHSSSlot;
+}
+
+std::vector<std::string> HothSKMHSSBlobHandler::getBlobIds()
+{
+    std::vector<std::string> result;
+    for (auto& [basePath, hothId] : hothIdBasePaths)
+    {
+        if (!dbus_->pingHothd(hothId))
+        {
+            continue;
+        }
+
+        result.emplace_back(basePath);
+        for (size_t i = 0; i < slotPopulated[basePath].size(); ++i)
+        {
+            if (slotPopulated[basePath][i])
+            {
+                result.emplace_back(fmt::format("{}{}", basePath, i));
+            }
+        }
+    }
+    return result;
+}
+
+bool HothSKMHSSBlobHandler::stat(const std::string& path, blobs::BlobMeta* meta)
+{
+    std::optional<uint32_t> slotPtr = internal::extractSlotFromID(path);
+    auto base = internal::getBaseFromID(path);
+    if (!slotPtr)
+    {
+        return false;
+    }
+    *meta = {};
+    return slotPopulated[base][*slotPtr];
+}
+
+bool HothSKMHSSBlobHandler::open(uint16_t session, uint16_t flags,
+                                 const std::string& path)
+{
+    std::optional<uint32_t> slotPtr = internal::extractSlotFromID(path);
+    if (!slotPtr)
+    {
+        return false;
+    }
+    std::string_view hothId = getHothIdFromPath(path);
+    if (!HothBlobHandler::open(session, flags, hothIdToPath(hothId)))
+    {
+        return false;
+    }
+
+    std::string_view base = internal::getBaseFromID(path);
+    sessionSlot[base].emplace(session, *slotPtr);
+    HothBlob* blobIt = getSession(session);
+
+    if (!(blobIt->state & blobs::StateFlags::open_read))
+    {
+        return true;
+    }
+    auto finalState = blobIt->state;
+    blobIt->state = blobs::StateFlags::committing;
+    blobIt->outstanding = readSKMHSSSlot(
+        base, *slotPtr, hothId,
+        [blobIt, finalState](std::span<const uint8_t> data) noexcept {
+            auto outstanding = std::move(blobIt->outstanding);
+            if (data.size() == SKM_HSS_STRUCT_SIZE)
+            {
+                /* Set committed to denote that our buffer is consistent with
+                 * the remote copy, making commits a no-op until a write changes
+                 * it.
+                 */
+                blobIt->state = finalState | blobs::StateFlags::committed;
+                blobIt->buffer = std::vector<uint8_t>(data.begin(), data.end());
+                return;
+            }
+            blobIt->state = blobs::StateFlags::commit_error;
+            if (data.data() != nullptr &&
+                finalState & blobs::StateFlags::open_write)
+            {
+                /* If the call succeeded, but we were uninitialized we want to
+                 * allow a write to continue accessing the blob. This requires
+                 * us to populate the open_* flags that were originally set on
+                 * the blob. We don't do this for RO blobs since they can't
+                 * fill in valid data to read back.
+                 */
+                blobIt->state |= finalState;
+            }
+        });
+    return true;
+}
+
+bool HothSKMHSSBlobHandler::commit(uint16_t session,
+                                   const std::vector<uint8_t>& data)
+{
+    if (!data.empty())
+    {
+        log<level::ERR>("Unexpected data provided to commit call");
+        return false;
+    }
+
+    HothBlob* blobIt = getSession(session);
+    if (!blobIt)
+    {
+        return false;
+    }
+    if (blobIt->state &
+        (blobs::StateFlags::committed | blobs::StateFlags::committing))
+    {
+        return true;
+    }
+
+    std::string_view base = getBaseFromHothId(blobIt->hothId);
+    /* Clear remaining commit bits */
+    blobIt->state &= ~blobs::StateFlags::commit_error;
+    uint32_t slot = sessionSlot[base][session];
+    std::vector<uint8_t> req;
+    try
+    {
+        req = hothUtil_->writeSKMHSS(slot, blobIt->buffer);
+    }
+    catch (const CommandFailure& e)
+    {
+        blobIt->state |= blobs::StateFlags::commit_error;
+        log<level::ERR>("Hoth command failed", entry("ERR_MSG=%s", e.what()));
+        return false;
+    }
+
+    blobIt->state |= blobs::StateFlags::committing;
+    blobIt->outstanding = dbus_->SendHostCommand(
+        blobIt->hothId, req,
+        [this, base, slot,
+         blobIt](std::optional<std::vector<uint8_t>> rsp) noexcept {
+            auto outstanding = std::move(blobIt->outstanding);
+            blobIt->state &= ~blobs::StateFlags::committing;
+            try
+            {
+                hothUtil_->payloadECResponse(rsp.value());
+                blobIt->state |= blobs::StateFlags::committed;
+                slotPopulated[base][slot] = true;
+                return;
+            }
+            catch (const ResponseFailure& e)
+            {
+                log<level::ERR>("Invalid Hoth response",
+                                entry("ERR_MSG=%s", e.what()));
+            }
+            catch (...)
+            {}
+            blobIt->state |= blobs::StateFlags::commit_error;
+        });
+    return true;
+}
+
+bool HothSKMHSSBlobHandler::stat(uint16_t session, blobs::BlobMeta* meta)
+{
+    HothBlob* blobIt = getSession(session);
+    if (!blobIt)
+    {
+        return false;
+    }
+
+    meta->size = blobIt->buffer.size();
+    meta->blobState = blobIt->state;
+    return true;
+}
+
+bool HothSKMHSSBlobHandler::deleteBlob(const std::string& path)
+{
+    std::optional<uint32_t> slotPtr = internal::extractSlotFromID(path);
+    std::string_view hothId = getHothIdFromPath(path);
+    auto base = internal::getBaseFromID(path);
+    if (!slotPtr)
+    {
+        return false;
+    }
+    auto& del = dels[base][*slotPtr];
+    if (del)
+    {
+        return true;
+    }
+    auto& pop = slotPopulated[base][*slotPtr];
+    del = dbus_->SendHostCommand(
+        hothId, hothUtil_->deleteSKMHSS(*slotPtr),
+        [&pop, &del, this](std::optional<std::vector<uint8_t>> rsp) noexcept {
+            auto adel = std::move(del);
+            try
+            {
+                hothUtil_->payloadECResponse(rsp.value());
+                pop = false;
+                return;
+            }
+            catch (const ResponseFailure& e)
+            {
+                log<level::ERR>("Invalid Hoth response",
+                                entry("ERR_MSG=%s", e.what()));
+            }
+            catch (...)
+            {}
+        });
+    return true;
+}
+
+bool HothSKMHSSBlobHandler::close(uint16_t session)
+{
+    HothBlob* blobIt = getSession(session);
+    if (!blobIt)
+    {
+        return false;
+    }
+
+    std::string_view base = getBaseFromHothId(blobIt->hothId);
+    if (HothBlobHandler::close(session))
+    {
+        sessionSlot[base].erase(session);
+        return true;
+    }
+    return false;
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/hoth_skmhss.hpp b/skmhss/hoth_skmhss.hpp
new file mode 100644
index 0000000..6fa84a0
--- /dev/null
+++ b/skmhss/hoth_skmhss.hpp
@@ -0,0 +1,127 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "command/dbus_command.hpp"
+#include "hoth.hpp"
+#include "hoth_util.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+#include <boost/bimap.hpp>
+#include <function2/function2.hpp>
+
+#include <array>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace ipmi_hoth
+{
+
+class HothSKMHSSBlobHandler : public HothBlobHandler
+{
+  public:
+    explicit HothSKMHSSBlobHandler(internal::DbusCommand* dbus,
+                                   internal::HothUtil* hvnutil) :
+        dbus_(dbus), hothUtil_(hvnutil)
+    {
+        loadHSS();
+    }
+
+    /* Our callbacks require pinned memory */
+    HothSKMHSSBlobHandler(HothSKMHSSBlobHandler&&) = delete;
+    HothSKMHSSBlobHandler& operator=(HothSKMHSSBlobHandler&&) = delete;
+
+    bool canHandleBlob(const std::string& path) override;
+    std::vector<std::string> getBlobIds() override;
+    bool deleteBlob(const std::string& path) override;
+    bool stat(const std::string& path, blobs::BlobMeta* meta) override;
+    bool open(uint16_t session, uint16_t flags, const std::string& path);
+    bool commit(uint16_t session, const std::vector<uint8_t>& data) override;
+    bool stat(uint16_t session, blobs::BlobMeta* meta) override;
+    bool close(uint16_t session) override;
+
+    internal::Dbus& dbus()
+    {
+        return *dbus_;
+    }
+
+    std::string_view pathSuffix() const override
+    {
+        return "skm/hss";
+    }
+    uint16_t requiredFlags() const override
+    {
+        return 0;
+    }
+    uint16_t maxSessions() const override
+    {
+        /* We should allow a limited number of sessions per-blob */
+        return maxNumHSSSlot << 2;
+    }
+
+    /* the max buffer size is the constant size of HSS. */
+    uint32_t maxBufferSize() const override
+    {
+        return 64;
+    }
+
+  private:
+    /** @brief Reads the HSS slot and store the HSS data
+     *  The return data can be null, meaning the request failed. It can also
+     *  be an empty buffer, so the caller needs to check that it has enough
+     *  bytes to be a valid HSS.
+     *
+     * @param[in] slot: the slot number in Hoth
+     * @param[in] cb:   Run when the request completes with the HSS bytes
+     * @returns An object to cancel the request early.
+     */
+    stdplus::Cancel readSKMHSSSlot(
+        std::string_view base, uint32_t slot, std::string_view hothId,
+        fu2::unique_function<void(std::span<const uint8_t>)>&& cb);
+
+    /* Load HSS on Hoth storage through reading all slots. */
+    void loadHSS();
+
+    /* read the hothid_basepaths.config and store it in basePathMap*/
+    void readBasePathConfig();
+
+    /* get the hoth Id from the path from hothIdBasePaths map */
+    std::string_view getHothIdFromPath(std::string_view path);
+
+    /* get the base path from the hoth Id from hothIdBasePaths map */
+    std::string_view getBaseFromHothId(std::string_view hothId);
+
+    /* Number of HSS seeds stored in Hoth */
+    static constexpr uint32_t maxNumHSSSlot = 4;
+
+    std::unordered_map<std::string_view, std::unordered_map<uint16_t, uint32_t>>
+        sessionSlot;
+    std::unordered_map<std::string_view, std::array<bool, maxNumHSSSlot>>
+        slotPopulated;
+    std::unordered_map<std::string_view,
+                       std::array<stdplus::Cancel, maxNumHSSSlot>>
+        inits, dels;
+
+    /* basePath <---> hothId mapping */
+    boost::bimap<std::string, std::string> hothIdBasePaths;
+
+    internal::DbusCommand* dbus_;
+    internal::HothUtil* hothUtil_;
+};
+
+} // namespace ipmi_hoth
diff --git a/skmhss/hoth_util.hpp b/skmhss/hoth_util.hpp
new file mode 100644
index 0000000..c8e9da7
--- /dev/null
+++ b/skmhss/hoth_util.hpp
@@ -0,0 +1,91 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stdplus/raw.hpp>
+
+#include <cstdint>
+#include <numeric>
+#include <span>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class HothUtil
+ *  @brief An interface to Hoth SKM HSS operation
+ *  @details Translate Hoth requests to bytes array commands and analyze
+ *  Hoth responses.
+ */
+class HothUtil
+{
+  public:
+    virtual ~HothUtil() {};
+
+    /** @brief Calculates the checksum for an EC request with the given
+     * |contents|
+     * @param one or more spans (or vectors) of bytes
+     * @returns the checksum for a message with the given |contents|
+     */
+
+    template <typename... Ts>
+    static uint8_t calculateChecksum(Ts&&... ts)
+    {
+        return (std::accumulate(std::begin(ts), std::end(ts), 0) + ...);
+    }
+
+    /** @brief Wrap the EC SKM HSS request by serializing the concatenation of
+     * an EC request header and payload
+     * @param request: the EC SKM HSS request
+     * @returns the serialized EC request
+     */
+    virtual std::vector<uint8_t>
+        wrapECSKMHSSRequest(std::span<const uint8_t> request) = 0;
+
+    /** @brief Wrap the EC SKM HSS read request
+     * @param slot: the slot number in Hoth
+     * @returns the serialized EC request
+     */
+    virtual std::vector<uint8_t> readSKMHSS(uint32_t slot) = 0;
+
+    /** @brief Wrap the EC SKM HSS write request
+     * @param slot: the slot number in Hoth
+     * @data data: SKM HSS bytes
+     * @returns the serialized EC request
+     */
+    virtual std::vector<uint8_t> writeSKMHSS(uint32_t slot,
+                                             std::span<const uint8_t> data) = 0;
+
+    /** @brief Wrap the EC SKM HSS delete request
+     * @param slot: the slot number in Hoth
+     * @returns the serialized EC request
+     */
+    virtual std::vector<uint8_t> deleteSKMHSS(uint32_t slot) = 0;
+
+    /** @brief Validate the EC response and extract the payload by stripping off
+     * the header
+     * @param rsp: bytes array representing response received from EC
+     * @returns return the payload in an EC response iff the EC response is
+     * valid.
+     */
+    virtual std::span<const uint8_t>
+        payloadECResponse(std::span<const uint8_t> rsp) = 0;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/skmhss/hoth_util_impl.cpp b/skmhss/hoth_util_impl.cpp
new file mode 100644
index 0000000..bdb3c2b
--- /dev/null
+++ b/skmhss/hoth_util_impl.cpp
@@ -0,0 +1,138 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_util_impl.hpp"
+
+#include <google3/g_ec_commands.h>
+#include <google3/host_commands.h>
+
+#include <boost/endian/conversion.hpp>
+#include <phosphor-logging/log.hpp>
+#include <stdplus/raw.hpp>
+#include <xyz/openbmc_project/Control/Hoth/error.hpp>
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <span>
+#include <vector>
+
+using CommandFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::CommandFailure;
+using ResponseFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::ResponseFailure;
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+using namespace phosphor::logging;
+
+std::vector<uint8_t>
+    HothUtilImpl::wrapECSKMHSSRequest(std::span<const uint8_t> request)
+{
+    // Populate EC request header based on the request
+    g_ec_host_request skmHssHeader = {
+        /*struct_version*/ G_EC_HOST_REQUEST_VERSION,
+        /*checksum*/ 0,
+        /*command*/ G_EC_PRIVATE_HOST_COMMAND_VALUE(EC_PRV_CMD_HOTH_SKM_HSS),
+        /*command_version*/ 0,
+        /*reserved*/ 0,
+        /*data_len*/ static_cast<uint16_t>(request.size())};
+
+    boost::endian::native_to_little_inplace(skmHssHeader);
+    skmHssHeader.checksum -=
+        calculateChecksum(stdplus::raw::asSpan<uint8_t>(skmHssHeader), request);
+
+    // Concatenate the request header and the request into one uint8_t vector to
+    // be sent to EC
+    const auto requestHeaderPtr = reinterpret_cast<uint8_t*>(&skmHssHeader);
+    std::vector<uint8_t> hothCommand(requestHeaderPtr,
+                                     requestHeaderPtr + sizeof(skmHssHeader));
+    hothCommand.insert(hothCommand.end(), request.begin(), request.end());
+    return hothCommand;
+}
+
+std::vector<uint8_t> HothUtilImpl::readSKMHSS(uint32_t slot)
+{
+    struct ec_request_skm_hss request = {};
+    request.operation = SKM_HSS_READ;
+    request.slot = slot;
+    return wrapECSKMHSSRequest(stdplus::raw::asSpan<const uint8_t>(request));
+}
+
+std::vector<uint8_t>
+    HothUtilImpl::writeSKMHSS(uint32_t slot, std::span<const uint8_t> data)
+{
+    if (data.empty() || data.size() > SKM_HSS_STRUCT_SIZE)
+    {
+        log<level::ERR>("Bad HSS payload size",
+                        entry("REQ_SIZE=%lu SKM_HSS_SIZE=%lu",
+                              static_cast<unsigned long>(data.size()),
+                              static_cast<unsigned long>(SKM_HSS_STRUCT_SIZE)));
+        throw CommandFailure();
+    }
+    struct ec_request_skm_hss request = {};
+    request.operation = SKM_HSS_WRITE;
+    request.slot = slot;
+    std::memcpy(request.payload.data, data.data(), data.size());
+    return wrapECSKMHSSRequest(stdplus::raw::asSpan<const uint8_t>(request));
+}
+
+std::vector<uint8_t> HothUtilImpl::deleteSKMHSS(uint32_t slot)
+{
+    struct ec_request_skm_hss request = {};
+    request.operation = SKM_HSS_DELETE;
+    request.slot = slot;
+    return wrapECSKMHSSRequest(stdplus::raw::asSpan<const uint8_t>(request));
+}
+
+std::span<const uint8_t>
+    HothUtilImpl::payloadECResponse(std::span<const uint8_t> rsp)
+{
+    g_ec_host_response header{};
+
+    if (rsp.size() < sizeof(header))
+    {
+        log<level::ERR>("Response is too short",
+                        entry("LENGTH=%d", rsp.size()));
+        throw ResponseFailure();
+    }
+
+    std::memcpy(&header, rsp.data(), sizeof(header));
+    boost::endian::native_to_little_inplace(header);
+
+    if (header.struct_version != G_EC_HOST_RESPONSE_VERSION)
+    {
+        log<level::ERR>(
+            "Unsupported stuct_version in response",
+            entry("VERSION=%d", static_cast<uint8_t>(header.struct_version)));
+        throw ResponseFailure();
+    }
+
+    if (header.result != EC_RES_SUCCESS && header.result != EC_RES_UNAVAILABLE)
+    {
+        log<level::ERR>(
+            "Unexpected return code",
+            entry("RESULT=%d", static_cast<uint16_t>(header.result)));
+        throw ResponseFailure();
+    }
+
+    return rsp.last(rsp.size() - sizeof(header));
+}
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/skmhss/hoth_util_impl.hpp b/skmhss/hoth_util_impl.hpp
new file mode 100644
index 0000000..96a1876
--- /dev/null
+++ b/skmhss/hoth_util_impl.hpp
@@ -0,0 +1,76 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "hoth_util.hpp"
+
+#include <stdplus/raw.hpp>
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/* Host command response codes (16-bit).  Note that response codes should be
+ * stored in a uint16_t rather than directly in a value of this type.
+ */
+enum ec_status
+{
+    EC_RES_SUCCESS = 0,
+    EC_RES_INVALID_COMMAND = 1,
+    EC_RES_ERROR = 2,
+    EC_RES_INVALID_PARAM = 3,
+    EC_RES_ACCESS_DENIED = 4,
+    EC_RES_INVALID_RESPONSE = 5,
+    EC_RES_INVALID_VERSION = 6,
+    EC_RES_INVALID_CHECKSUM = 7,
+    EC_RES_IN_PROGRESS = 8,             /* Accepted, command in progress */
+    EC_RES_UNAVAILABLE = 9,             /* No response available */
+    EC_RES_TIMEOUT = 10,                /* We got a timeout */
+    EC_RES_OVERFLOW = 11,               /* Table / data overflow */
+    EC_RES_INVALID_HEADER = 12,         /* Header contains invalid data */
+    EC_RES_REQUEST_TRUNCATED = 13,      /* Didn't get the entire request */
+    EC_RES_RESPONSE_TOO_BIG = 14,       /* Response was too big to handle */
+    EC_RES_BUS_ERROR = 15,              /* Communications bus error */
+    EC_RES_BUSY = 16,                   /* Up but too busy.  Should retry */
+    EC_RES_INVALID_HEADER_VERSION = 17, /* Header version invalid */
+    EC_RES_INVALID_HEADER_CRC = 18,     /* Header CRC invalid */
+    EC_RES_INVALID_DATA_CRC = 19,       /* Data CRC invalid */
+    EC_RES_DUP_UNAVAILABLE = 20,        /* Can't resend response */
+};
+
+/** @class HothUtilImpl
+ * @brief Implementation of HothUtil interface
+ */
+class HothUtilImpl : public HothUtil
+{
+  public:
+    std::vector<uint8_t>
+        wrapECSKMHSSRequest(std::span<const uint8_t> request) override;
+    std::vector<uint8_t> readSKMHSS(uint32_t slot) override;
+    std::vector<uint8_t> writeSKMHSS(uint32_t slot,
+                                     std::span<const uint8_t> data) override;
+    std::vector<uint8_t> deleteSKMHSS(uint32_t slot) override;
+    std::span<const uint8_t>
+        payloadECResponse(std::span<const uint8_t> rsp) override;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/skmhss/main_skmhss.cpp b/skmhss/main_skmhss.cpp
new file mode 100644
index 0000000..48bd97b
--- /dev/null
+++ b/skmhss/main_skmhss.cpp
@@ -0,0 +1,31 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "command/dbus_command_impl.hpp"
+#include "hoth_skmhss.hpp"
+#include "hoth_util_impl.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <memory>
+
+extern "C" std::unique_ptr<blobs::GenericBlobInterface> createHandler()
+{
+    /** @brief Default instantiation of Dbus and HothUtil */
+    static ipmi_hoth::internal::DbusCommandImpl dbusCommand_impl;
+    static ipmi_hoth::internal::HothUtilImpl hothUtil_impl;
+
+    return std::make_unique<ipmi_hoth::HothSKMHSSBlobHandler>(
+        &dbusCommand_impl, &hothUtil_impl);
+}
diff --git a/skmhss/meson.build b/skmhss/meson.build
new file mode 100644
index 0000000..7a713a5
--- /dev/null
+++ b/skmhss/meson.build
@@ -0,0 +1,45 @@
+meson.get_compiler('cpp').has_header_symbol(
+  'boost/endian/conversion.hpp',
+  'boost::endian::native_to_little_inplace')
+
+conf_data = configuration_data()
+conf_data.set_quoted('HOTHID_CONFIG', get_option('skmhss-hothid-config'))
+conf_hpp = configure_file(
+  output: 'config.hpp',
+  configuration: conf_data)
+
+hothskmhss_pre = declare_dependency(
+  include_directories: include_directories('.'),
+  dependencies: [
+    hothblob_dep,
+    hothcommand_dep,
+    dependency('hothd-dbus'),
+    ipmi_blob_dep,
+    phosphor_logging_dep,
+    sdbusplus_dep,
+    stdplus_dep,
+  ])
+
+hothskmhss_lib = static_library(
+  'hothskmhss',
+  'hoth_skmhss.cpp',
+  'hoth_util_impl.cpp',
+  conf_hpp,
+  implicit_include_directories: false,
+  dependencies: hothskmhss_pre)
+
+hothskmhss_dep = declare_dependency(
+  link_with: hothskmhss_lib,
+  dependencies: hothskmhss_pre)
+
+shared_module(
+  'hothskmhss',
+  'main_skmhss.cpp',
+  implicit_include_directories: false,
+  dependencies: hothskmhss_dep,
+  install: true,
+  install_dir: get_option('libdir') / 'blob-ipmid')
+
+if not get_option('tests').disabled()
+  subdir('test')
+endif
diff --git a/skmhss/test/hoth_skmhss_close_unittest.cpp b/skmhss/test/hoth_skmhss_close_unittest.cpp
new file mode 100644
index 0000000..924a51c
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_close_unittest.cpp
@@ -0,0 +1,50 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+class HothSKMHSSCloseTest : public HothSKMHSSBasicTest
+{};
+
+TEST_F(HothSKMHSSCloseTest, CloseWithInvalidSessionFails)
+{
+    // Verify you cannot close an invalid session.
+
+    EXPECT_FALSE(hvn->close(session));
+}
+
+TEST_F(HothSKMHSSCloseTest, CloseWithValidSessionSuccess)
+{
+    // Verify you can close a valid session.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn->open(session, blobs::OpenFlags::write, legacyPath[2]));
+    EXPECT_TRUE(hvn->close(session));
+    EXPECT_FALSE(hvn->close(session));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_commit_unittest.cpp b/skmhss/test/hoth_skmhss_commit_unittest.cpp
new file mode 100644
index 0000000..a2aa971
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_commit_unittest.cpp
@@ -0,0 +1,120 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::Return;
+using ::testing::UnorderedElementsAreArray;
+
+namespace ipmi_hoth
+{
+
+class HothSKMHSSCommitTest : public HothSKMHSSBasicTest
+{
+  protected:
+    void openAndWriteRandomHss(int idx)
+    {
+        std::vector<uint8_t> data(64);
+        std::srand(1);
+        std::generate(data.begin(), data.end(), std::rand);
+        EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+            .WillOnce(Return(true));
+        fu2::unique_function<void()> cb;
+        testing::StrictMock<MockCancel> cancel;
+        expectRead(idx, cb, cancel, data);
+        EXPECT_TRUE(
+            hvn->open(session, blobs::OpenFlags::read | blobs::OpenFlags::write,
+                      legacyPath[idx]));
+        cb();
+    }
+};
+
+TEST_F(HothSKMHSSCommitTest, InvalidSessionCommitIsRejected)
+{
+    // Verify the hoth command handler checks for a valid session.
+
+    EXPECT_FALSE(hvn->commit(session, std::vector<uint8_t>()));
+}
+
+TEST_F(HothSKMHSSCommitTest, CommitWithUnexpectedDataParamReturnsFalse)
+{
+    openAndWriteRandomHss(0);
+    EXPECT_FALSE(hvn->commit(session, std::vector<uint8_t>({1, 2, 3})));
+}
+
+TEST_F(HothSKMHSSCommitTest, MultiCommit)
+{
+    openAndWriteRandomHss(1);
+
+    // No change does nothing
+    EXPECT_TRUE(hvn->commit(session, {}));
+
+    EXPECT_TRUE(hvn->write(session, 0, {0}));
+
+    // Test an error case
+    EXPECT_CALL(hvnutil, writeSKMHSS(1, _))
+        .WillOnce(Return(std::vector<uint8_t>{11}));
+    fu2::unique_function<void()> cb;
+    testing::StrictMock<MockCancel> cancel;
+    expectCmd(/*slot=*/1, cb, cancel, /*data=*/{});
+    EXPECT_TRUE(hvn->commit(session, {}));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_write |
+                  blobs::StateFlags::open_read,
+              meta.blobState);
+
+    cb();
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(blobs::StateFlags::commit_error | blobs::StateFlags::open_write |
+                  blobs::StateFlags::open_read,
+              meta.blobState);
+
+    // Test repeat commit translates into success
+    EXPECT_CALL(hvnutil, writeSKMHSS(1, _))
+        .WillOnce(Return(std::vector<uint8_t>{11}));
+    std::array<uint8_t, 1> arr;
+    expectCmd(/*slot=*/1, cb, cancel,
+              /*data=*/std::span<uint8_t>(arr).subspan(0, 0));
+    EXPECT_TRUE(hvn->commit(session, {}));
+
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(blobs::StateFlags::committing | blobs::StateFlags::open_write |
+                  blobs::StateFlags::open_read,
+              meta.blobState);
+
+    cb();
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(blobs::StateFlags::committed | blobs::StateFlags::open_write |
+                  blobs::StateFlags::open_read,
+              meta.blobState);
+
+    // No change does nothing
+    EXPECT_TRUE(hvn->commit(session, {}));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_delete_unittest.cpp b/skmhss/test/hoth_skmhss_delete_unittest.cpp
new file mode 100644
index 0000000..a3518bf
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_delete_unittest.cpp
@@ -0,0 +1,107 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::UnorderedElementsAreArray;
+
+namespace ipmi_hoth
+{
+
+class HothSKMHSSDeleteTest : public HothSKMHSSBasicTest
+{};
+
+TEST_F(HothSKMHSSDeleteTest, DeleteWithNoHothd)
+{
+    DbusCommand::Cb cb;
+    testing::StrictMock<MockCancel> cancel;
+    EXPECT_CALL(hvnutil, deleteSKMHSS).WillOnce(Return(std::vector<uint8_t>()));
+    EXPECT_CALL(dbus, SendHostCommand("", testing::ElementsAre(), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&,
+                      DbusCommand::Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(&cancel);
+        });
+    EXPECT_TRUE(hvn->deleteBlob("/skm/hss-backup/0"));
+    // Delete while delete in progress should not trigger a new delete
+    EXPECT_TRUE(hvn->deleteBlob("/skm/hss-backup/0"));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat("/skm/hss-backup/0", &meta));
+    EXPECT_CALL(cancel, cancel());
+    cb(std::nullopt);
+    EXPECT_TRUE(hvn->stat("/skm/hss-backup/0", &meta));
+}
+
+TEST_F(HothSKMHSSDeleteTest, DeleteSlotSucceeds)
+{
+    // Also check the cached blob list is updated.
+    std::vector<std::string> expected = {
+        "/skm/hss-backup/",  "/skm/hss-backup/0", "/skm/hss-backup/1",
+        "/skm/hss-backup/2", "/skm/hss-backup/3",
+    };
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    EXPECT_THAT(hvn->getBlobIds(), UnorderedElementsAreArray(expected));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat("/skm/hss-backup/0", &meta));
+
+    DbusCommand::Cb cb;
+    testing::StrictMock<MockCancel> cancel;
+    EXPECT_CALL(hvnutil, deleteSKMHSS).WillOnce(Return(std::vector<uint8_t>()));
+    EXPECT_CALL(dbus, SendHostCommand("", testing::ElementsAre(), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&,
+                      DbusCommand::Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(&cancel);
+        });
+    EXPECT_CALL(hvnutil, payloadECResponse(_))
+        .WillOnce(Return(std::vector<uint8_t>()));
+
+    EXPECT_TRUE(hvn->deleteBlob(legacyPath[3]));
+    EXPECT_TRUE(hvn->stat("/skm/hss-backup/3", &meta));
+    EXPECT_THAT(hvn->getBlobIds(), UnorderedElementsAreArray(expected));
+    EXPECT_CALL(cancel, cancel());
+    cb(std::vector<uint8_t>());
+    expected.pop_back();
+    EXPECT_THAT(hvn->getBlobIds(), UnorderedElementsAreArray(expected));
+    EXPECT_FALSE(hvn->stat("/skm/hss-backup/3", &meta));
+
+    // Deleting a nonexistent slot will fall through to hoth
+    EXPECT_CALL(hvnutil, deleteSKMHSS).WillOnce(Return(std::vector<uint8_t>()));
+    EXPECT_CALL(dbus, SendHostCommand("", testing::ElementsAre(), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&,
+                      DbusCommand::Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(&cancel);
+        });
+    EXPECT_TRUE(hvn->deleteBlob(legacyPath[3]));
+    EXPECT_CALL(cancel, cancel());
+    cb(std::nullopt);
+
+    // Opening deleted slot succeeds
+    EXPECT_CALL(dbus, pingHothd("")).WillOnce(Return(true));
+    EXPECT_TRUE(hvn->open(session, blobs::OpenFlags::write, legacyPath[3]));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_open_unittest.cpp b/skmhss/test/hoth_skmhss_open_unittest.cpp
new file mode 100644
index 0000000..033492f
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_open_unittest.cpp
@@ -0,0 +1,121 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <span>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+class HothSKMHSSOpenTest : public HothSKMHSSBasicTest
+{};
+
+TEST_F(HothSKMHSSOpenTest, OpenWithNoHothd)
+{
+    /* Hoth SKM HSS handler opens without a backing hoth daemon present. */
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(false));
+    EXPECT_FALSE(hvn->open(session, hvn->requiredFlags(), legacyPath[1]));
+}
+
+TEST_F(HothSKMHSSOpenTest, OpenRWUninitializedBlobSucceeds)
+{
+    /* Hoth SKM HSS handler opens an uninitialized path. */
+    hvn = createHandlerWithEmptyCache();
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    fu2::unique_function<void()> cb;
+    testing::StrictMock<MockCancel> cancel;
+    std::array<uint8_t, 1> rspdata;
+    expectRead(0, cb, cancel, std::span<uint8_t>(rspdata).subspan(0, 0));
+    EXPECT_TRUE(
+        hvn->open(session, blobs::OpenFlags::read | blobs::OpenFlags::write,
+                  legacyPath[0]));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState, blobs::StateFlags::committing);
+    cb();
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_read | blobs::StateFlags::open_write |
+                  blobs::StateFlags::commit_error);
+}
+
+TEST_F(HothSKMHSSOpenTest, OpenROUninitializedBlobFails)
+{
+    /* Hoth SKM HSS handler opens an uninitialized path. */
+    hvn = createHandlerWithEmptyCache();
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    fu2::unique_function<void()> cb;
+    testing::StrictMock<MockCancel> cancel;
+    std::array<uint8_t, 1> rspdata;
+    expectRead(0, cb, cancel, std::span<uint8_t>(rspdata).subspan(0, 0));
+    EXPECT_TRUE(hvn->open(session, blobs::OpenFlags::read, legacyPath[0]));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState, blobs::StateFlags::committing);
+    cb();
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState, blobs::StateFlags::commit_error);
+}
+
+TEST_F(HothSKMHSSOpenTest, OpenBlobWithSdBusErrorFails)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    fu2::unique_function<void()> cb;
+    testing::StrictMock<MockCancel> cancel;
+    expectRead(0, cb, cancel, {});
+    EXPECT_TRUE(
+        hvn->open(session, blobs::OpenFlags::read | blobs::OpenFlags::write,
+                  legacyPath[0]));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState, blobs::StateFlags::committing);
+    cb();
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.blobState, blobs::StateFlags::commit_error);
+}
+
+TEST_F(HothSKMHSSOpenTest, OpenOverloadedSessionFails)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    uint16_t sessId = 0;
+    int low = std::min((uint16_t)legacyPath.size(), hvn->maxSessions());
+
+    for (int i = 0; i < low; i++)
+    {
+        EXPECT_TRUE(
+            hvn->open(sessId++, blobs::OpenFlags::write, legacyPath[i]));
+    }
+
+    for (int i = low; i < hvn->maxSessions(); i++)
+    {
+        EXPECT_TRUE(
+            hvn->open(sessId++, blobs::OpenFlags::write, legacyPath[0]));
+    }
+
+    EXPECT_FALSE(hvn->open(sessId++, blobs::OpenFlags::write, legacyPath[0]));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_read_unittest.cpp b/skmhss/test/hoth_skmhss_read_unittest.cpp
new file mode 100644
index 0000000..c47eef9
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_read_unittest.cpp
@@ -0,0 +1,154 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+#include <ipmid/handler.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::ElementsAre;
+using ::testing::IsEmpty;
+using ::testing::Return;
+
+class HothSKMHSSReadTest : public HothSKMHSSBasicTest
+{
+  protected:
+    const uint32_t testOffset = 0;
+    const std::vector<uint8_t> testData = [] {
+        std::vector<uint8_t> ret;
+        for (uint8_t i = 0; i < 64; ++i)
+            ret.push_back(i);
+        return ret;
+    }();
+
+    void openUninitializedBlob(int idx)
+    {
+        // Any valid blobs have uninitialized buffer.
+        hvn = createHandlerWithEmptyCache();
+
+        EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+            .WillOnce(Return(true));
+        fu2::unique_function<void()> cb;
+        testing::StrictMock<MockCancel> cancel;
+        expectRead(idx, cb, cancel, testData);
+        EXPECT_TRUE(
+            hvn->open(session, blobs::OpenFlags::read, legacyPath[idx]));
+        cb();
+    }
+};
+
+TEST_F(HothSKMHSSReadTest, InvalidSessionReadIsRejected)
+{
+    // Verify that read checks for a valid session, returns empty buffer for
+    // failed check.
+
+    openUninitializedBlob(0);
+    uint16_t wrongSession = session + 1;
+    EXPECT_THROW(hvn->read(wrongSession, testOffset, testData.size()),
+                 ipmi::HandlerCompletion);
+}
+
+TEST_F(HothSKMHSSReadTest, ReadOpenBlobWithoutReadFlagReturnsError)
+{
+    // Verify that read checks for a valid state with open_read flag set.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn->open(session, 0, legacyPath[1]));
+    EXPECT_THROW(hvn->read(session, testOffset, testData.size()),
+                 ipmi::HandlerCompletion);
+}
+
+TEST_F(HothSKMHSSReadTest, ReadOffsetBeyondBufferSizeReturnsEmpty)
+{
+    // Verify that read with offset beyond buffer size returns empty buffer.
+
+    openUninitializedBlob(2);
+    uint32_t offsetBeyondBuffer = testData.size();
+    EXPECT_THAT(hvn->read(session, offsetBeyondBuffer, testData.size()),
+                IsEmpty());
+}
+
+TEST_F(HothSKMHSSReadTest, ReadFullWrittenData)
+{
+    // Verify that the read successfully reads back the written data.
+
+    openUninitializedBlob(3);
+    EXPECT_THAT(hvn->read(session, testOffset, testData.size()),
+                ContainerEq(testData));
+}
+
+TEST_F(HothSKMHSSReadTest, ReadWrittenDataAtOffset)
+{
+    // Verify that the read with offset returns the expected data.
+
+    openUninitializedBlob(0);
+    EXPECT_THAT(hvn->read(session, testOffset, testData.size()),
+                ContainerEq(testData));
+
+    // Try reading the written data byte by byte at each offset
+    for (size_t i = 0; i < testData.size(); ++i)
+    {
+        EXPECT_THAT(hvn->read(session, i, 1), ElementsAre(testData[i]));
+    }
+}
+
+TEST_F(HothSKMHSSReadTest, ReadFullWrittenDataWithBiggerRequestedSize)
+{
+    // Verify that read with requested size bigger than the written data will
+    // return a response buffer up to the end of the written buffer.
+
+    openUninitializedBlob(0);
+    uint32_t requestedSizeBeyondBuffer = testData.size() + 1;
+    EXPECT_THAT(hvn->read(session, testOffset, requestedSizeBeyondBuffer),
+                ContainerEq(testData));
+}
+
+TEST_F(HothSKMHSSReadTest, ReadWrittenDataAtOffsetWithBiggerRequestedSize)
+{
+    // Verify that read with requested size bigger than the written data at an
+    // offset will return a response buffer up to the end of the written buffer.
+
+    openUninitializedBlob(1);
+    uint32_t newOffset = testData.size() / 2;
+    uint32_t requestedSizeBeyondBuffer = testData.size() + 1;
+    std::vector<uint8_t> expectedData =
+        std::vector<uint8_t>(testData.begin() + newOffset, testData.end());
+
+    EXPECT_THAT(hvn->read(session, newOffset, requestedSizeBeyondBuffer),
+                ContainerEq(expectedData));
+}
+
+TEST_F(HothSKMHSSReadTest, ReadFullWrittenDataBeyondMaxBufferSize)
+{
+    // Verify that read with requested size bigger than the maximum buffer size
+    // will return a response buffer up to the end of the written buffer.
+
+    openUninitializedBlob(2);
+    uint32_t requestedSize = hvn->maxBufferSize() + 1;
+    EXPECT_THAT(hvn->read(session, testOffset, requestedSize),
+                ContainerEq(testData));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_unittest.cpp b/skmhss/test/hoth_skmhss_unittest.cpp
new file mode 100644
index 0000000..4784603
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_unittest.cpp
@@ -0,0 +1,76 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::Return;
+using ::testing::UnorderedElementsAreArray;
+
+namespace ipmi_hoth
+{
+
+TEST_F(HothSKMHSSBasicTest, HothIdMainOnly)
+{
+    EXPECT_EQ("", hvn->pathToHothId(hvn->hothIdToPath("")));
+}
+
+TEST_F(HothSKMHSSBasicTest, CanHandleBlobChecksNameInvalid)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    EXPECT_FALSE(hvn->canHandleBlob("asdf"));
+    EXPECT_FALSE(hvn->canHandleBlob("/skm/hss-backup"));
+    EXPECT_FALSE(hvn->canHandleBlob("/skm/hss-backup/4"));
+    EXPECT_FALSE(hvn->canHandleBlob("/skm/hss-backup/15"));
+    EXPECT_FALSE(hvn->canHandleBlob("/dev/hoth/command_passthru"));
+}
+
+TEST_F(HothSKMHSSBasicTest, CanHandleBlobChecksNameValid)
+{
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    EXPECT_TRUE(hvn->canHandleBlob("/skm/hss-backup/0"));
+    EXPECT_TRUE(hvn->canHandleBlob("/skm/hss-backup/1"));
+    EXPECT_TRUE(hvn->canHandleBlob("/skm/hss-backup/2"));
+    EXPECT_TRUE(hvn->canHandleBlob("/skm/hss-backup/3"));
+}
+
+TEST_F(HothSKMHSSBasicTest, GetBlobIdsAsHssUnintialized)
+{
+    hvn = createHandlerWithEmptyCache();
+    std::vector<std::string> expected = {"/skm/hss-backup/"};
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_THAT(hvn->getBlobIds(), ContainerEq(expected));
+}
+
+TEST_F(HothSKMHSSBasicTest, GetBlobIdsAsHssCommited)
+{
+    std::vector<std::string> expected = {
+        "/skm/hss-backup/",  "/skm/hss-backup/0", "/skm/hss-backup/1",
+        "/skm/hss-backup/2", "/skm/hss-backup/3",
+    };
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+    EXPECT_THAT(hvn->getBlobIds(), UnorderedElementsAreArray(expected));
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_unittest.hpp b/skmhss/test/hoth_skmhss_unittest.hpp
new file mode 100644
index 0000000..0973205
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_unittest.hpp
@@ -0,0 +1,154 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "command/test/dbus_command_mock.hpp"
+#include "hoth_skmhss.hpp"
+#include "hoth_util_mock.hpp"
+
+#include <sdbusplus/exception.hpp>
+#include <sdbusplus/test/sdbus_mock.hpp>
+#include <xyz/openbmc_project/Control/Hoth/error.hpp>
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using ipmi_hoth::internal::DbusCommand;
+using ::testing::_;
+using ::testing::NotNull;
+using ::testing::Return;
+using ResponseFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::ResponseFailure;
+
+namespace ipmi_hoth
+{
+
+struct MockCancel : public stdplus::Cancelable
+{
+    MOCK_METHOD(void, cancel, (), (noexcept, override));
+};
+
+class HothSKMHSSTest : public ::testing::Test
+{
+  public:
+    void expectCmd(uint8_t i, fu2::unique_function<void()>& cb,
+                   MockCancel& cancel, std::span<const uint8_t> data)
+    {
+        bool has_data = data.data() != nullptr;
+        EXPECT_CALL(dbus,
+                    SendHostCommand(
+                        "", testing::ElementsAre(static_cast<uint8_t>(10 + i)),
+                        _))
+            .WillOnce([&cb, &cancel, i,
+                       has_data](std::string_view, const std::vector<uint8_t>&,
+                                 DbusCommand::Cb&& icb) {
+                if (has_data)
+                {
+                    cb = [icb = std::move(icb), i]() mutable {
+                        icb(std::vector<uint8_t>{static_cast<uint8_t>(20 + i)});
+                    };
+                }
+                else
+                {
+                    cb = [icb = std::move(icb)]() mutable {
+                        icb(std::nullopt);
+                    };
+                }
+                return stdplus::Cancel(&cancel);
+            });
+        if (has_data)
+        {
+            EXPECT_CALL(hvnutil, payloadECResponse(testing::ElementsAre(
+                                     static_cast<uint8_t>(20 + i))))
+                .WillOnce(Return(data));
+        }
+        EXPECT_CALL(cancel, cancel()).WillOnce(Return());
+    }
+
+    void expectRead(uint8_t i, fu2::unique_function<void()>& cb,
+                    MockCancel& cancel, std::span<const uint8_t> data)
+    {
+        EXPECT_CALL(hvnutil, readSKMHSS(i))
+            .WillOnce(
+                Return(std::vector<uint8_t>{static_cast<uint8_t>(10 + i)}));
+        expectCmd(i, cb, cancel, data);
+    }
+
+    std::unique_ptr<HothSKMHSSBlobHandler>
+        createHandler(const std::vector<uint8_t>& data)
+    {
+        std::array<fu2::unique_function<void()>, 4> cbs;
+        std::array<testing::StrictMock<MockCancel>, 4> cancels;
+        for (uint8_t i = 0; i < 4; ++i)
+        {
+            expectRead(i, cbs[i], cancels[i], data);
+        }
+        auto ret = std::make_unique<HothSKMHSSBlobHandler>(&dbus, &hvnutil);
+        for (uint8_t i = 0; i < 4; ++i)
+        {
+            cbs[i]();
+        }
+        testing::Mock::VerifyAndClearExpectations(&hvnutil);
+        testing::Mock::VerifyAndClearExpectations(&dbus);
+        return ret;
+    }
+
+    // Create a handler with empty HSS cache.
+    std::unique_ptr<HothSKMHSSBlobHandler> createHandlerWithEmptyCache()
+    {
+        return createHandler({});
+    }
+
+    // Create a handler with test HSS cache.
+    std::unique_ptr<HothSKMHSSBlobHandler> createHandlerWithTestCache()
+    {
+        return createHandler(testHSSBytes);
+    }
+
+  protected:
+    // dbus mock object
+    testing::StrictMock<internal::DbusCommandMock> dbus;
+
+    // Hoth utility mock object
+    testing::StrictMock<internal::HothUtilMock> hvnutil;
+
+    const uint16_t session = 0;
+    const std::vector<std::string> legacyPath = {
+        "/skm/hss-backup/0",
+        "/skm/hss-backup/1",
+        "/skm/hss-backup/2",
+        "/skm/hss-backup/3",
+    };
+    const std::vector<uint8_t> testHSSBytes = std::vector<uint8_t>(64, 0x0b);
+};
+
+class HothSKMHSSBasicTest : public HothSKMHSSTest
+{
+  public:
+    HothSKMHSSBasicTest() :
+        hvn(HothSKMHSSBasicTest::createHandlerWithTestCache())
+    {}
+    std::unique_ptr<HothSKMHSSBlobHandler> hvn;
+};
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_skmhss_write_unittest.cpp b/skmhss/test/hoth_skmhss_write_unittest.cpp
new file mode 100644
index 0000000..7098550
--- /dev/null
+++ b/skmhss/test/hoth_skmhss_write_unittest.cpp
@@ -0,0 +1,119 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_skmhss_unittest.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+class HothSKMHSSWriteTest : public HothSKMHSSBasicTest
+{
+  protected:
+    void openWriteCachedBlob(int)
+    {
+        EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+            .WillOnce(Return(true));
+        EXPECT_TRUE(hvn->open(session, blobs::OpenFlags::write, legacyPath[1]));
+    }
+};
+
+TEST_F(HothSKMHSSWriteTest, InvalidSessionWriteIsRejected)
+{
+    // Verify the hoth command handler checks for a valid session.
+
+    std::vector<uint8_t> data = {0x1, 0x2};
+
+    EXPECT_FALSE(hvn->write(session, 0, data));
+    blobs::BlobMeta meta;
+    EXPECT_FALSE(hvn->stat(session, &meta));
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingTooMuchByOneByteFails)
+{
+    // Test the edge case of writing 1 byte too much with an offset of 0.
+    // writing 65 at offset 0 is invalid.
+
+    openWriteCachedBlob(0);
+    std::vector<uint8_t> data(hvn->maxBufferSize() + 1, 0x11);
+    EXPECT_FALSE(hvn->write(session, 0, data));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.size, 0);
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingTooMuchByOffsetOfOneFails)
+{
+    // Test the edge case of writing 64 bytes (which is fine) but at the
+    // offset 1, which makes it go over by 1 byte. Writing 64 at offset 1 is
+    // invalid.
+
+    openWriteCachedBlob(1);
+    std::vector<uint8_t> data(hvn->maxBufferSize(), 0x11);
+    EXPECT_FALSE(hvn->write(session, 1, data));
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingOneByteBeyondEndFromOffsetFails)
+{
+    // Test the edge case of writing to the last byte offset but trying to
+    // write two bytes. Writing 2 bytes at 63 is invalid.
+
+    openWriteCachedBlob(2);
+    std::vector<uint8_t> data = {0x01, 0x02};
+    EXPECT_FALSE(hvn->write(session, (hvn->maxBufferSize() - 1), data));
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingOneByteAtOffsetBeyondEndFails)
+{
+    // Test the edge case of writing one byte but exactly one byte beyond the
+    // buffer. Writing 1 byte at 64 is invalid.
+
+    openWriteCachedBlob(3);
+    std::vector<uint8_t> data = {0x01};
+    EXPECT_FALSE(hvn->write(session, hvn->maxBufferSize(), data));
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingFullBufferAtOffsetZeroSucceeds)
+{
+    // Test the case where you write the full buffer length at once to the 0th
+    // offset.
+
+    openWriteCachedBlob(0);
+    std::vector<uint8_t> data(hvn->maxBufferSize(), 0x11);
+    EXPECT_TRUE(hvn->write(session, 0, data));
+}
+
+TEST_F(HothSKMHSSWriteTest, WritingOneByteToTheLastOffsetSucceeds)
+{
+    // Test the case where you write the last byte.
+
+    openWriteCachedBlob(0);
+    std::vector<uint8_t> data = {0x01};
+    EXPECT_TRUE(hvn->write(session, (hvn->maxBufferSize() - 1), data));
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn->stat(session, &meta));
+    EXPECT_EQ(meta.size, 64);
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_util_mock.hpp b/skmhss/test/hoth_util_mock.hpp
new file mode 100644
index 0000000..61334df
--- /dev/null
+++ b/skmhss/test/hoth_util_mock.hpp
@@ -0,0 +1,47 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "hoth_util.hpp"
+
+#include <stdplus/raw.hpp>
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+#include <gmock/gmock.h>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+class HothUtilMock : public HothUtil
+{
+  public:
+    MOCK_METHOD1(wrapECSKMHSSRequest,
+                 std::vector<uint8_t>(std::span<const uint8_t> request));
+    MOCK_METHOD1(readSKMHSS, std::vector<uint8_t>(uint32_t slot));
+    MOCK_METHOD2(writeSKMHSS,
+                 std::vector<uint8_t>(uint32_t slot,
+                                      std::span<const uint8_t> data));
+    MOCK_METHOD1(deleteSKMHSS, std::vector<uint8_t>(uint32_t slot));
+    MOCK_METHOD1(payloadECResponse,
+                 std::span<const uint8_t>(std::span<const uint8_t> rsp));
+};
+
+} // namespace internal
+} // namespace ipmi_hoth
diff --git a/skmhss/test/hoth_util_unittest.cpp b/skmhss/test/hoth_util_unittest.cpp
new file mode 100644
index 0000000..0b71526
--- /dev/null
+++ b/skmhss/test/hoth_util_unittest.cpp
@@ -0,0 +1,173 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus_mock.hpp"
+#include "hoth_util.hpp"
+#include "hoth_util_impl.hpp"
+
+#include <xyz/openbmc_project/Control/Hoth/error.hpp>
+
+#include <algorithm>
+#include <cstdint>
+#include <numeric>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace ::testing;
+using CommandFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::CommandFailure;
+using ResponseFailure =
+    sdbusplus::xyz::openbmc_project::Control::Hoth::Error::ResponseFailure;
+
+namespace ipmi_hoth
+{
+
+using namespace internal;
+
+class HothUtilTest : public ::testing::Test
+{
+  protected:
+    HothUtilTest() : hothUtil(std::make_unique<HothUtilImpl>(HothUtilImpl())) {}
+
+    std::unique_ptr<HothUtil> hothUtil;
+};
+
+TEST_F(HothUtilTest, Checksum)
+{
+    uint8_t header[] = {1, 3, 5, 7};
+    uint8_t body[] = {2, 4, 6, 8};
+
+    // (1 + 3 + 5 + 7) + (2 + 4 + 6 + 8) = 36
+    EXPECT_EQ(36, HothUtil::calculateChecksum(header, body));
+
+    // Now test what happens if the sum exceeds 256.
+    body[0] = 200;
+    body[1] = 202;
+
+    // (1 + 3 + 5 + 7) + (200 + 202 + 6 + 8) = 432
+    // 432 % 256 = 176
+    EXPECT_EQ(176, HothUtil::calculateChecksum(header, body));
+}
+
+TEST_F(HothUtilTest, WrapECSKMHSSRequest)
+{
+    std::vector<uint8_t> request(15);
+    std::generate(request.begin(), request.end(), std::rand);
+    std::vector<uint8_t> reqBytes;
+    reqBytes = std::move(hothUtil->wrapECSKMHSSRequest(request));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+}
+
+TEST_F(HothUtilTest, ReadSKMHSS)
+{
+    std::vector<uint8_t> reqBytes;
+    reqBytes = std::move(hothUtil->readSKMHSS(0));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->readSKMHSS(1));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->readSKMHSS(2));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->readSKMHSS(3));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+}
+
+TEST_F(HothUtilTest, WriteSKMHSS)
+{
+    std::vector<uint8_t> payload(128);
+    std::vector<uint8_t> reqBytes;
+    std::generate(payload.begin(), payload.end(), std::rand);
+    EXPECT_THROW(hothUtil->writeSKMHSS(0, payload), CommandFailure);
+    EXPECT_TRUE(reqBytes.empty());
+
+    payload.resize(64);
+    reqBytes = std::move(hothUtil->writeSKMHSS(1, payload));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    payload = {0, 0, 0, 0,   0,   0,   0,  0,  0, 0, 0, 0, 0,   0,  0, 0,
+               0, 0, 0, 0,   0,   0,   0,  0,  0, 0, 0, 0, 0,   0,  0, 0,
+               0, 0, 0, 0,   0,   0,   0,  0,  0, 0, 0, 0, 0,   0,  0, 0,
+               0, 0, 1, 110, 205, 147, 54, 43, 0, 0, 1, 1, 175, 58, 9, 239};
+    EXPECT_NO_THROW(hothUtil->writeSKMHSS(0, payload));
+    EXPECT_NO_THROW(hothUtil->writeSKMHSS(1, payload));
+    EXPECT_NO_THROW(hothUtil->writeSKMHSS(2, payload));
+    EXPECT_NO_THROW(hothUtil->writeSKMHSS(3, payload));
+}
+
+TEST_F(HothUtilTest, DeleteSKMHSS)
+{
+    std::vector<uint8_t> reqBytes;
+    reqBytes = std::move(hothUtil->deleteSKMHSS(0));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->deleteSKMHSS(1));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->deleteSKMHSS(2));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+
+    reqBytes = std::move(hothUtil->deleteSKMHSS(3));
+    EXPECT_FALSE(reqBytes.empty());
+    EXPECT_EQ(0, HothUtil::calculateChecksum(reqBytes));
+}
+
+TEST_F(HothUtilTest, PayloadECResponse)
+{
+    std::vector<uint8_t> validRsp = {0x03, 0xfd, 0x00, 0x00,
+                                     0x00, 0x00, 0x00, 0x00};
+    EXPECT_NO_THROW(hothUtil->payloadECResponse(validRsp));
+
+    std::vector<uint8_t> rspShortLength = {0x03, 0xfd};
+    EXPECT_THROW(hothUtil->payloadECResponse(rspShortLength), ResponseFailure);
+
+    std::vector<uint8_t> rspVersionErr = {0x05, 0xfb, 0x00, 0x00,
+                                          0x00, 0x00, 0x00, 0x00};
+    EXPECT_THROW(hothUtil->payloadECResponse(rspVersionErr), ResponseFailure);
+
+    std::vector<uint8_t> rspNonZeroRC = {0x03, 0xfc, 0x01, 0x00,
+                                         0x00, 0x00, 0x00, 0x00};
+    EXPECT_THROW(hothUtil->payloadECResponse(rspNonZeroRC), ResponseFailure);
+
+    std::vector<uint8_t> rspExpectedNonZeroRC = {0x03, 0xf4, 0x09, 0x00,
+                                                 0x00, 0x00, 0x00, 0x00};
+    EXPECT_NO_THROW(hothUtil->payloadECResponse(rspExpectedNonZeroRC));
+
+    std::vector<uint8_t> payload(64);
+    std::generate(payload.begin(), payload.end(), std::rand);
+    uint8_t payloadSum =
+        std::accumulate(std::begin(payload), std::end(payload), 0) % 256;
+    uint8_t checksum = 0x100 - (0x03 + 0x40 + payloadSum) % 256;
+    std::vector<uint8_t> validRspWithRandomHss = {0x03, 0x00, 0x00, 0x00,
+                                                  0x40, 0x00, 0x00, 0x00};
+    validRspWithRandomHss[1] = checksum;
+    validRspWithRandomHss.insert(validRspWithRandomHss.end(), payload.begin(),
+                                 payload.end());
+    auto data = hothUtil->payloadECResponse(validRspWithRandomHss);
+    EXPECT_EQ(std::vector<uint8_t>(data.begin(), data.end()), payload);
+}
+
+} // namespace ipmi_hoth
diff --git a/skmhss/test/meson.build b/skmhss/test/meson.build
new file mode 100644
index 0000000..89bc57c
--- /dev/null
+++ b/skmhss/test/meson.build
@@ -0,0 +1,20 @@
+tests = [
+  'hoth_skmhss_unittest',
+  'hoth_skmhss_close_unittest',
+  'hoth_skmhss_commit_unittest',
+  'hoth_skmhss_delete_unittest',
+  'hoth_skmhss_open_unittest',
+  'hoth_skmhss_read_unittest',
+  'hoth_skmhss_write_unittest',
+  'hoth_util_unittest',
+]
+
+foreach t : tests
+  test(
+    t,
+    executable(
+      t.underscorify(),
+      t + '.cpp',
+      implicit_include_directories: false,
+      dependencies: [hothskmhss_dep, test_dep]))
+endforeach
diff --git a/test/dbus_mock.hpp b/test/dbus_mock.hpp
new file mode 100644
index 0000000..a2a9ed3
--- /dev/null
+++ b/test/dbus_mock.hpp
@@ -0,0 +1,45 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus.hpp"
+
+#include <ipmid/api.h>
+#include <systemd/sd-bus.h>
+
+#include <string_view>
+
+#include <gmock/gmock.h>
+
+sd_bus* ipmid_get_sd_bus_connection()
+{
+    return nullptr;
+}
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+class DbusMock : public virtual Dbus
+{
+  public:
+    MOCK_METHOD0(getHothdMapping, SubTreeMapping());
+    MOCK_METHOD1(pingHothd, bool(std::string_view));
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/test/meson.build b/test/meson.build
new file mode 100644
index 0000000..4eed4c0
--- /dev/null
+++ b/test/meson.build
@@ -0,0 +1,6 @@
+gtest = dependency('gtest', main: true, disabler: true, required: get_option('tests'))
+gmock = dependency('gmock', disabler: true, required: get_option('tests'))
+
+test_dep = declare_dependency(
+  include_directories: include_directories('.'),
+  dependencies: [gtest, gmock])
diff --git a/update/dbus_update.hpp b/update/dbus_update.hpp
new file mode 100644
index 0000000..7ec3b23
--- /dev/null
+++ b/update/dbus_update.hpp
@@ -0,0 +1,73 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus.hpp"
+
+#include <function2/function2.hpp>
+#include <stdplus/cancel.hpp>
+#include <xyz/openbmc_project/Control/Hoth/server.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class DbusUpdate
+ *  @brief Overridable D-Bus interface for command handler
+ */
+class DbusUpdate : public virtual Dbus
+{
+  public:
+    using FirmwareUpdateStatus = sdbusplus::xyz::openbmc_project::Control::
+        server::Hoth::FirmwareUpdateStatus;
+
+    using Cb = fu2::unique_function<void(FirmwareUpdateStatus)>;
+
+    /** @brief Implementation for UpdateFirmware
+     *  Executes hothd's updateFirmware with the given firmware binary. This
+     *  is an asynchronous call and should not return anything. Poll the status
+     *  of the update with GetFirmwareUpdateStatus.
+     *
+     *  @param[in] hothId - The identifier of the targeted hoth instance.
+     *  @param[in] firmwareData - Firmware binary to write to Hoth's
+     *                            firmware update SPI partition
+     *  @param[in] cb - The callback to execute when the request completes.
+     *  @return cancelable[stdplus::Cancel] - Drop to cancel the command early.
+     */
+    virtual stdplus::Cancel
+        UpdateFirmware(std::string_view hothId,
+                       const std::vector<uint8_t>& firmwareData, Cb&& cb) = 0;
+
+    /** @brief Implementation for GetFirmwareUpdateStatus
+     *  Executes hothd's getFirmwareUpdateStatus. This is an asynchronous call
+     *  that returns the status of the write to Hoth's firmware update SPI
+     *  partition.
+     *
+     *  @param[in] hothId - The identifier of the targeted hoth instance.
+     *  @param[in] cb - The callback to execute when the request completes.
+     *  @return cancelable[stdplus::Cancel] - Drop to cancel the command early.
+     */
+    virtual stdplus::Cancel
+        GetFirmwareUpdateStatus(std::string_view hothId, Cb&& cb) = 0;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/update/dbus_update_impl.cpp b/update/dbus_update_impl.cpp
new file mode 100644
index 0000000..c739ddf
--- /dev/null
+++ b/update/dbus_update_impl.cpp
@@ -0,0 +1,88 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus_update_impl.hpp"
+
+#include <fmt/format.h>
+
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+stdplus::Cancel DbusUpdateImpl::UpdateFirmware(
+    std::string_view hothId, const std::vector<uint8_t>& firmwareData, Cb&& cb)
+{
+    auto req = newHothdCall(hothId, "UpdateFirmware");
+    req.append(firmwareData);
+    auto cHothId = std::string(hothId);
+    return stdplus::Cancel(new BusCall(req.call_async(
+        [cb = std::move(cb), hothId = std::move(cHothId)](
+            sdbusplus::message::message m) mutable noexcept {
+            if (m.is_method_error())
+            {
+                auto err = m.get_error();
+                fmt::print(stderr, "UpdateFirmware failed on `{}`: {}: {}\n",
+                           hothId, err->name, err->message);
+                cb(FirmwareUpdateStatus::Error);
+                return;
+            }
+            cb(FirmwareUpdateStatus::InProgress);
+        },
+        asyncCallTimeout)));
+}
+
+stdplus::Cancel
+    DbusUpdateImpl::GetFirmwareUpdateStatus(std::string_view hothId, Cb&& cb)
+{
+    auto req = newHothdCall(hothId, "GetFirmwareUpdateStatus");
+    auto cHothId = std::string(hothId);
+    return stdplus::Cancel(new BusCall(req.call_async(
+        [cb = std::move(cb), hothId = std::move(cHothId)](
+            sdbusplus::message::message m) mutable noexcept {
+            if (m.is_method_error())
+            {
+                auto err = m.get_error();
+                fmt::print(stderr,
+                           "GetFirmwareUpdateStatus failed on `{}`: {}: {}\n",
+                           hothId, err->name, err->message);
+                cb(FirmwareUpdateStatus::Error);
+                return;
+            }
+            try
+            {
+                std::string rsp;
+                m.read(rsp);
+                cb(sdbusplus::xyz::openbmc_project::Control::server::Hoth::
+                       convertFirmwareUpdateStatusFromString(rsp));
+            }
+            catch (const std::exception& e)
+            {
+                fmt::print(
+                    stderr,
+                    "GetFirmwareUpdateStatus failed unpacking on `{}`: {}\n",
+                    hothId, e.what());
+                cb(FirmwareUpdateStatus::Error);
+            }
+        },
+        asyncCallTimeout)));
+}
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/update/dbus_update_impl.hpp b/update/dbus_update_impl.hpp
new file mode 100644
index 0000000..60a2370
--- /dev/null
+++ b/update/dbus_update_impl.hpp
@@ -0,0 +1,45 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_impl.hpp"
+#include "dbus_update.hpp"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+/** @class DbusImpl
+ *  @brief D-Bus concrete implementation
+ *  @details Pass through all calls to the default D-Bus instance
+ */
+class DbusUpdateImpl : public DbusUpdate, public DbusImpl
+{
+  public:
+    stdplus::Cancel UpdateFirmware(std::string_view hothId,
+                                   const std::vector<uint8_t>& firmwareData,
+                                   Cb&& cb) override;
+    stdplus::Cancel GetFirmwareUpdateStatus(std::string_view hothId,
+                                            Cb&& cb) override;
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/update/hoth_update.cpp b/update/hoth_update.cpp
new file mode 100644
index 0000000..59a6e33
--- /dev/null
+++ b/update/hoth_update.cpp
@@ -0,0 +1,130 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update.hpp"
+
+#include <phosphor-logging/log.hpp>
+#include <sdbusplus/message.hpp>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+using phosphor::logging::entry;
+using phosphor::logging::log;
+
+using level = phosphor::logging::level;
+using SdBusError = sdbusplus::exception::SdBusError;
+
+namespace ipmi_hoth
+{
+
+void updateBlobState(uint16_t& state,
+                     internal::DbusUpdate::FirmwareUpdateStatus st)
+{
+    state &= ~(blobs::StateFlags::commit_error | blobs::StateFlags::committing |
+               blobs::StateFlags::committed);
+    switch (st)
+    {
+        case internal::DbusUpdate::FirmwareUpdateStatus::None:
+            break;
+        case internal::DbusUpdate::FirmwareUpdateStatus::InProgress:
+            state |= blobs::StateFlags::committing;
+            break;
+        case internal::DbusUpdate::FirmwareUpdateStatus::Error:
+            state |= blobs::StateFlags::commit_error;
+            break;
+        case internal::DbusUpdate::FirmwareUpdateStatus::Done:
+            state |= blobs::StateFlags::committed;
+            break;
+    }
+}
+
+bool HothUpdateBlobHandler::stat(const std::string& path, blobs::BlobMeta* meta)
+{
+    std::optional<uint16_t> sess = getOnlySession(pathToHothId(path));
+    if (!sess)
+    {
+        return false;
+    }
+
+    /* Call session stat with the session ID of the only session */
+    return stat(*sess, meta);
+}
+
+bool HothUpdateBlobHandler::commit(uint16_t session,
+                                   const std::vector<uint8_t>& data)
+{
+    if (!data.empty())
+    {
+        log<level::ERR>("Unexpected data provided to commit call");
+        return false;
+    }
+
+    HothBlob* sess = getSession(session);
+    if (!sess)
+    {
+        return false;
+    }
+
+    // If commit is called multiple times, return the same result as last time
+    if (sess->state &
+        (blobs::StateFlags::committing | blobs::StateFlags::committed))
+    {
+        return true;
+    }
+
+    updateBlobState(sess->state,
+                    internal::DbusUpdate::FirmwareUpdateStatus::InProgress);
+    sess->outstanding = dbus_->UpdateFirmware(
+        sess->hothId, sess->buffer,
+        [sess](internal::DbusUpdate::FirmwareUpdateStatus rsp) {
+            auto outstanding = std::move(sess->outstanding);
+            updateBlobState(sess->state, rsp);
+        });
+    return true;
+}
+
+bool HothUpdateBlobHandler::stat(uint16_t session, blobs::BlobMeta* meta)
+{
+    HothBlob* sess = getSession(session);
+    if (!sess)
+    {
+        // Return false since blobs::BlobMeta was not updated
+        return false;
+    }
+
+    // We only want to start a new status check if we don't have a pending job
+    // and we hoth't receivied a completion state (error / done).
+    if (!sess->outstanding && (sess->state & blobs::StateFlags::committing))
+    {
+        sess->outstanding = dbus_->GetFirmwareUpdateStatus(
+            sess->hothId,
+            [sess](internal::DbusUpdate::FirmwareUpdateStatus rsp) {
+                auto outstanding = std::move(sess->outstanding);
+                updateBlobState(sess->state, rsp);
+            });
+    }
+
+    meta->size = sess->buffer.size();
+    meta->blobState = sess->state;
+    // Return true since blobs::BlobMeta was updated
+    return true;
+}
+
+} // namespace ipmi_hoth
diff --git a/update/hoth_update.hpp b/update/hoth_update.hpp
new file mode 100644
index 0000000..1dab418
--- /dev/null
+++ b/update/hoth_update.hpp
@@ -0,0 +1,68 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_update.hpp"
+#include "hoth.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ipmi_hoth
+{
+
+class HothUpdateBlobHandler : public HothBlobHandler
+{
+  public:
+    explicit HothUpdateBlobHandler(internal::DbusUpdate* dbus) : dbus_(dbus) {}
+
+    /* Our callbacks require pinned memory */
+    HothUpdateBlobHandler(HothUpdateBlobHandler&&) = delete;
+    HothUpdateBlobHandler& operator=(HothUpdateBlobHandler&&) = delete;
+
+    bool stat(const std::string& path, blobs::BlobMeta* meta) override;
+    bool commit(uint16_t session, const std::vector<uint8_t>& data) override;
+    bool stat(uint16_t session, blobs::BlobMeta* meta) override;
+
+    internal::Dbus& dbus() override
+    {
+        return *dbus_;
+    }
+    std::string_view pathSuffix() const override
+    {
+        return "firmware_update";
+    }
+    uint16_t requiredFlags() const override
+    {
+        return blobs::OpenFlags::write;
+    }
+    uint16_t maxSessions() const override
+    {
+        return 1;
+    }
+    uint32_t maxBufferSize() const override
+    {
+        return 1024 * 1024;
+    }
+
+  private:
+    internal::DbusUpdate* dbus_;
+};
+
+} // namespace ipmi_hoth
diff --git a/update/main_update.cpp b/update/main_update.cpp
new file mode 100644
index 0000000..fee3735
--- /dev/null
+++ b/update/main_update.cpp
@@ -0,0 +1,28 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dbus_update_impl.hpp"
+#include "hoth_update.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <memory>
+
+extern "C" std::unique_ptr<blobs::GenericBlobInterface> createHandler()
+{
+    /** @brief Default instantiation of Dbus */
+    static ipmi_hoth::internal::DbusUpdateImpl dbusUpdate_impl;
+
+    return std::make_unique<ipmi_hoth::HothUpdateBlobHandler>(&dbusUpdate_impl);
+}
diff --git a/update/meson.build b/update/meson.build
new file mode 100644
index 0000000..1d2ae5d
--- /dev/null
+++ b/update/meson.build
@@ -0,0 +1,31 @@
+hothupdate_pre = declare_dependency(
+  include_directories: include_directories('.'),
+  dependencies: [
+    hothblob_dep,
+    dependency('hothd-dbus'),
+    phosphor_logging_dep,
+    sdbusplus_dep,
+  ])
+
+hothupdate_lib = static_library(
+  'hothupdate',
+  'dbus_update_impl.cpp',
+  'hoth_update.cpp',
+  implicit_include_directories: false,
+  dependencies: hothupdate_pre)
+
+hothupdate_dep = declare_dependency(
+  link_with: hothupdate_lib,
+  dependencies: hothupdate_pre)
+
+shared_module(
+  'hothupdate',
+  'main_update.cpp',
+  implicit_include_directories: false,
+  dependencies: hothupdate_dep,
+  install: true,
+  install_dir: get_option('libdir') / 'blob-ipmid')
+
+if not get_option('tests').disabled()
+  subdir('test')
+endif
diff --git a/update/test/dbus_update_mock.hpp b/update/test/dbus_update_mock.hpp
new file mode 100644
index 0000000..334d4be
--- /dev/null
+++ b/update/test/dbus_update_mock.hpp
@@ -0,0 +1,40 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_mock.hpp"
+#include "dbus_update.hpp"
+
+#include <gmock/gmock.h>
+
+namespace ipmi_hoth
+{
+namespace internal
+{
+
+class DbusUpdateMock : public DbusUpdate, public DbusMock
+{
+  public:
+    MOCK_METHOD(stdplus::Cancel, UpdateFirmware,
+                (std::string_view hothId,
+                 const std::vector<uint8_t>& firmwareData, Cb&& cb),
+                (override));
+    MOCK_METHOD(stdplus::Cancel, GetFirmwareUpdateStatus,
+                (std::string_view hothId, Cb&& cb), (override));
+};
+
+} // namespace internal
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_close_unittest.cpp b/update/test/hoth_update_close_unittest.cpp
new file mode 100644
index 0000000..c069a9b
--- /dev/null
+++ b/update/test/hoth_update_close_unittest.cpp
@@ -0,0 +1,58 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothUpdateCloseTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateCloseTest, CloseWithInvalidSessionFails)
+{
+    // Verify you cannot close an invalid session.
+
+    EXPECT_FALSE(hvn.close(session_));
+}
+
+TEST_F(HothUpdateCloseTest, CloseWithValidSessionSuccess)
+{
+    // Verify you can close a valid session.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.close(session_));
+}
+
+TEST_F(HothUpdateCloseTest, CloseValidSessionTwiceFails)
+{
+    // Verify that close actually closes the session, expect the second close
+    // of the same session to fail.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.close(session_));
+    EXPECT_FALSE(hvn.close(session_));
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_commit_unittest.cpp b/update/test/hoth_update_commit_unittest.cpp
new file mode 100644
index 0000000..1421c74
--- /dev/null
+++ b/update/test/hoth_update_commit_unittest.cpp
@@ -0,0 +1,216 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <gmock/gmock.h>
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::IsEmpty;
+using ::testing::NotNull;
+using ::testing::Return;
+
+using namespace std::literals;
+
+namespace ipmi_hoth
+{
+
+using Cb = internal::DbusUpdate::Cb;
+using FirmwareUpdateStatus = internal::DbusUpdate::FirmwareUpdateStatus;
+
+class HothUpdateCommitTest : public HothUpdateTest
+{
+  protected:
+    template <typename Req>
+    void expectUpdate(std::string_view hothId, Req&& req)
+    {
+        EXPECT_CALL(dbus, UpdateFirmware(hothId, req, _))
+            .WillOnce(
+                [&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+                    cb = std::move(icb);
+                    return stdplus::Cancel(std::nullopt);
+                });
+    }
+
+    Cb cb;
+};
+
+const auto static test_str = "Hello,\0 world!"s;
+const std::vector<uint8_t> static test_buf(test_str.begin(), test_str.end());
+
+TEST_F(HothUpdateCommitTest, InvalidSessionCommitIsRejected)
+{
+    // Verify the hoth update handler checks for a valid session.
+
+    EXPECT_FALSE(hvn.commit(session_, std::vector<uint8_t>()));
+}
+
+TEST_F(HothUpdateCommitTest, NonEmptyDataParamFails)
+{
+    // Verify that we do not accept any data passed into the commit call.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.commit(session_, std::vector<uint8_t>({1, 2, 3})));
+}
+
+TEST_F(HothUpdateCommitTest, DbusExceptionSetsCommitErrorStateAndFails)
+{
+    // Verify that when the dbus call hits an exception, commit method fails
+    // and that the state is set to blobs::StateFlags::commit_error
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectUpdate(/*hothId=*/"", ContainerEq(test_buf));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Error);
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::commit_error);
+}
+
+TEST_F(HothUpdateCommitTest, EmptyBufferCommitLegacyHothSuccessful)
+{
+    // Verify that we are able to succssfully commit an empty buffer
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectUpdate(/*hothId=*/"", IsEmpty());
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // No write call to populate the buffer here
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Done);
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.size, 0);
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::committed);
+}
+
+TEST_F(HothUpdateCommitTest, EmptyBufferCommitNamedHothSuccessful)
+{
+    // Verify that we are able to succssfully commit an empty buffer
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(name))).WillOnce(Return(true));
+    expectUpdate(/*hothId=*/name, IsEmpty());
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), namedPath));
+    // No write call to populate the buffer here
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Done);
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.size, 0);
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::committed);
+}
+
+TEST_F(HothUpdateCommitTest, NonEmptyBufferCommitSuccessful)
+{
+    // Verify that we are able to succssfully commit a buffer with valid data
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectUpdate(/*hothId=*/"", ContainerEq(test_buf));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Done);
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.size, test_buf.size());
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::committed);
+}
+
+TEST_F(HothUpdateCommitTest, IdempotentSuccess)
+{
+    // Verify that repeated successful commits only result in one D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+    expectUpdate(/*hothId=*/"", IsEmpty());
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // No write call to populate the buffer here
+
+    // These calls will return due to the state being "committing". Calling
+    // stat is the only way to check if the state has changed to "committed"
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Done);
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    // These calls will return due to the state being "committed"
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    // Stat is also idempotent, no need to mock the D-Bus call here
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.size, 0);
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::committed);
+}
+
+TEST_F(HothUpdateCommitTest, ErrorRetry)
+{
+    // Verify that commit after error retries the update D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    // These calls will return due to the state being "commit_error"
+    expectUpdate(/*hothId=*/"", IsEmpty());
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Error);
+    expectUpdate(/*hothId=*/"", IsEmpty());
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Error);
+    expectUpdate(/*hothId=*/"", IsEmpty());
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Error);
+
+    blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::commit_error);
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_delete_unittest.cpp b/update/test/hoth_update_delete_unittest.cpp
new file mode 100644
index 0000000..41aa16e
--- /dev/null
+++ b/update/test/hoth_update_delete_unittest.cpp
@@ -0,0 +1,32 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+class HothUpdateDeleteTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateDeleteTest, VerifyHothDeleteFails)
+{
+    // The hoth update handler does not support delete.
+
+    EXPECT_FALSE(hvn.deleteBlob(legacyPath));
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_open_unittest.cpp b/update/test/hoth_update_open_unittest.cpp
new file mode 100644
index 0000000..f3aeaae
--- /dev/null
+++ b/update/test/hoth_update_open_unittest.cpp
@@ -0,0 +1,75 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothUpdateOpenTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateOpenTest, OpenWithBadFlagsFails)
+{
+    // Hoth update handler open requires the write flag.
+
+    EXPECT_FALSE(hvn.open(session_, blobs::OpenFlags::read, legacyPath));
+}
+
+TEST_F(HothUpdateOpenTest, OpenEverythingSucceeds)
+{
+    // Hoth update handler open with everything correct.
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+}
+
+TEST_F(HothUpdateOpenTest, OpenSecondSessionFails)
+{
+    // Hoth update handler only allows 1 open session, verify second one fails
+    // regardless of whether the session ID is the same or not
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.open(session_ + 1, hvn.requiredFlags(), legacyPath));
+}
+
+TEST_F(HothUpdateOpenTest, OpenCloseOpenSucceeds)
+{
+    // Hoth update handler should be able to open a session after closing an
+    // open one
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view("")))
+        .WillRepeatedly(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.close(session_));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_read_unittest.cpp b/update/test/hoth_update_read_unittest.cpp
new file mode 100644
index 0000000..faa05b2
--- /dev/null
+++ b/update/test/hoth_update_read_unittest.cpp
@@ -0,0 +1,44 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <ipmid/handler.hpp>
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothUpdateReadTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateReadTest, VerifyHothReadFails)
+{
+    // The hoth update handler does not support read, expect empty vector
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_THROW(hvn.read(session_, 0, 1), ipmi::HandlerCompletion);
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_stat_unittest.cpp b/update/test/hoth_update_stat_unittest.cpp
new file mode 100644
index 0000000..54b66f1
--- /dev/null
+++ b/update/test/hoth_update_stat_unittest.cpp
@@ -0,0 +1,379 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <string_view>
+#include <vector>
+
+#include <gmock/gmock.h>
+
+using ::testing::_;
+using ::testing::ContainerEq;
+using ::testing::NotNull;
+using ::testing::Return;
+
+using namespace std::literals;
+
+namespace ipmi_hoth
+{
+
+using Cb = internal::DbusUpdate::Cb;
+using FirmwareUpdateStatus = internal::DbusUpdate::FirmwareUpdateStatus;
+
+class HothUpdateStatTest : public HothUpdateTest
+{
+  protected:
+    blobs::BlobMeta meta_;
+    // Initialize expected_meta_ with empty members
+    blobs::BlobMeta expected_meta_;
+};
+class HothUpdateSessionStatTest : public HothUpdateStatTest
+{};
+
+struct MockCancel : stdplus::Cancelable
+{
+    MOCK_METHOD(void, cancel, (), (noexcept, override));
+};
+
+const auto static test_str = "Hello,\0 world!"s;
+const std::vector<uint8_t> static test_buf(test_str.begin(), test_str.end());
+
+TEST_F(HothUpdateStatTest, InvalidStatIsRejected)
+{
+    // Verify the hoth update handler checks for a valid session.
+
+    EXPECT_FALSE(hvn.stat(legacyPath, &meta_));
+}
+
+TEST_F(HothUpdateStatTest, StatBeforeCommitReturnsInitialState)
+{
+    // Verify stat returns initial state before commit
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.stat(legacyPath, &meta_));
+
+    expected_meta_.size = 0;
+    expected_meta_.blobState = blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+// Rest of the tests will be using session stat, since
+// stat with blob ID calls session ID after the initial checks
+
+TEST_F(HothUpdateSessionStatTest, InvalidSessionStatIsRejected)
+{
+    // Verify the hoth update handler checks for a valid session.
+
+    EXPECT_FALSE(hvn.stat(0, &meta_));
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatBeforeCommitReturnsInitialState)
+{
+    // Verify the session stat before commit returns initial state
+    // without any D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    expected_meta_.size = 0;
+    expected_meta_.blobState = blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatAfterWriteMetadataLengthMatches)
+{
+    // Verify that after writes, the length returned matches
+    // without any D-bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    // We wrote one byte to the last index, making the length the buffer size.
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState = blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatAfterErrorCommitReturnsStatus)
+{
+    // Verify that after commit errors out early, the session stat
+    // returns the initial status without any D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+    EXPECT_FALSE(hvn.commit(session_, std::vector<uint8_t>({1, 2, 3})));
+
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState = blobs::StateFlags::open_write;
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatErrorReturnsCommitError)
+{
+    // Verify that mocking GetFirmwareUpdateStatus ouptut to Error after
+    // a successful commit makes session stat return 'commit_error' status
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::InProgress);
+
+    EXPECT_CALL(dbus, GetFirmwareUpdateStatus(std::string_view(""), _))
+        .WillOnce([&](std::string_view, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    struct blobs::BlobMeta meta;
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+
+    EXPECT_EQ(meta.size, test_buf.size());
+    EXPECT_EQ(meta.metadata.size(), 0);
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::committing);
+
+    cb(FirmwareUpdateStatus::Error);
+    EXPECT_TRUE(hvn.stat(session_, &meta));
+    EXPECT_EQ(meta.blobState,
+              blobs::StateFlags::open_write | blobs::StateFlags::commit_error);
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatInProgressReturnsCommitting)
+{
+    // Verify that mocking GetFirmwareUpdateStatus ouptut to InProgress after
+    // a successful commit makes session stat return 'committing' status
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::InProgress);
+
+    EXPECT_CALL(dbus, GetFirmwareUpdateStatus(std::string_view(""), _))
+        .Times(2)
+        .WillRepeatedly([&](std::string_view, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    cb(FirmwareUpdateStatus::InProgress);
+
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::committing;
+    EXPECT_EQ(meta_, expected_meta_);
+
+    // Check that repeated stats after callback trigger another call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, SessionStatDoneReturnsCommitted)
+{
+    // Verify that mocking GetFirmwareUpdateStatus ouptut to Done after
+    // a successful commit makes session stat return 'committed' status
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::InProgress);
+
+    EXPECT_CALL(dbus, GetFirmwareUpdateStatus(std::string_view(""), _))
+        .WillOnce([&](std::string_view, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::committing;
+    EXPECT_EQ(meta_, expected_meta_);
+
+    cb(FirmwareUpdateStatus::Done);
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::committed;
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, MultipleInProgressReturnsCommitting)
+{
+    // Verify that repeated session stat calls while committing
+    // result in multiple D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    testing::StrictMock<MockCancel> c;
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(&c);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+
+    // If commit is still outstanding we should not issue a new command
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::committing;
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+
+    EXPECT_CALL(c, cancel());
+    cb(FirmwareUpdateStatus::InProgress);
+    testing::Mock::VerifyAndClearExpectations(&c);
+
+    EXPECT_CALL(dbus, GetFirmwareUpdateStatus(std::string_view(""), _))
+        .WillOnce([&](std::string_view, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(&c);
+        });
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+
+    EXPECT_CALL(c, cancel());
+    cb(FirmwareUpdateStatus::InProgress);
+}
+
+TEST_F(HothUpdateSessionStatTest, IdempotentDoneReturnsCommitted)
+{
+    // Verify that repeated session stat calls while status is committed
+    // result in one D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Done);
+
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::committed;
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+TEST_F(HothUpdateSessionStatTest, IdempotentErrorReturnsCommitError)
+{
+    // Verify that repeated session stat calls while status is commit_error
+    // result in one D-Bus call
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+    // session, offset, data
+    EXPECT_TRUE(hvn.write(session_, 0, test_buf));
+
+    Cb cb;
+    EXPECT_CALL(dbus,
+                UpdateFirmware(std::string_view(""), ContainerEq(test_buf), _))
+        .WillOnce([&](std::string_view, const std::vector<uint8_t>&, Cb&& icb) {
+            cb = std::move(icb);
+            return stdplus::Cancel(std::nullopt);
+        });
+    EXPECT_TRUE(hvn.commit(session_, std::vector<uint8_t>()));
+    cb(FirmwareUpdateStatus::Error);
+
+    expected_meta_.size = test_buf.size();
+    expected_meta_.blobState =
+        blobs::StateFlags::open_write | blobs::StateFlags::commit_error;
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+    // Shouldn't trigger a new call
+    EXPECT_TRUE(hvn.stat(session_, &meta_));
+    EXPECT_EQ(meta_, expected_meta_);
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_unittest.cpp b/update/test/hoth_update_unittest.cpp
new file mode 100644
index 0000000..87ef59a
--- /dev/null
+++ b/update/test/hoth_update_unittest.cpp
@@ -0,0 +1,70 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using ::testing::Return;
+using ::testing::UnorderedElementsAreArray;
+
+namespace ipmi_hoth
+{
+
+class HothUpdateBasicTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateBasicTest, CanHandleBlobChecksNameInvalid)
+{
+    // Verify canHandleBlob checks and returns false on an invalid name.
+
+    EXPECT_FALSE(hvn.canHandleBlob("asdf"));
+    EXPECT_FALSE(hvn.canHandleBlob("dev/hoth/firmware_update"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/firmware_update2"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/hoth0/t/firmware_update"));
+    EXPECT_FALSE(hvn.canHandleBlob("/dev/hoth/command_passthru"));
+}
+
+TEST_F(HothUpdateBasicTest, CanHandleBlobChecksNameValid)
+{
+    // Verify canHandleBlob checks and returns true on the valid name.
+
+    EXPECT_TRUE(hvn.canHandleBlob("/dev/hoth/firmware_update"));
+    EXPECT_TRUE(hvn.canHandleBlob("/dev/hoth/hoth0/firmware_update"));
+}
+
+TEST_F(HothUpdateBasicTest, VerifyBehaviorOfBlobIds)
+{
+    // Verify the correct BlobIds is returned from the hoth update handler.
+    internal::Dbus::SubTreeMapping mapping = {
+        {"/xyz/openbmc_project/Control", {}},
+        {"/xyz/openbmc_project/Control/Hoth2nologue", {}},
+        {"/xyz/openbmc_project/Control/Hoth/nologue/2", {}},
+        {"/xyz/openbmc_project/Control/Hoth", {}},
+        {"/xyz/openbmc_project/Control/Hoth/hoth0", {}},
+        {"/xyz/openbmc_project/Control/Hoth/hoth1", {}},
+    };
+    EXPECT_CALL(dbus, getHothdMapping()).WillOnce(Return(mapping));
+    std::vector<std::string> expected = {
+        "/dev/hoth/firmware_update",
+        "/dev/hoth/hoth0/firmware_update",
+        "/dev/hoth/hoth1/firmware_update",
+    };
+    EXPECT_THAT(hvn.getBlobIds(), UnorderedElementsAreArray(expected));
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_unittest.hpp b/update/test/hoth_update_unittest.hpp
new file mode 100644
index 0000000..56bb72b
--- /dev/null
+++ b/update/test/hoth_update_unittest.hpp
@@ -0,0 +1,48 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "dbus_update_mock.hpp"
+#include "hoth_update.hpp"
+
+#include <stdplus/util/string.hpp>
+
+#include <cstdint>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+class HothUpdateTest : public ::testing::Test
+{
+  protected:
+    explicit HothUpdateTest() : hvn(&dbus) {}
+
+    // dbus mock object
+    testing::StrictMock<internal::DbusUpdateMock> dbus;
+
+    HothUpdateBlobHandler hvn;
+
+    const uint16_t session_ = 0;
+    const std::string legacyPath = stdplus::util::strCat(
+        HothUpdateBlobHandler::hothPathPrefix, hvn.pathSuffix());
+    const std::string name = "hoth0";
+    const std::string namedPath = stdplus::util::strCat(
+        HothUpdateBlobHandler::hothPathPrefix, name, "/", hvn.pathSuffix());
+};
+
+} // namespace ipmi_hoth
diff --git a/update/test/hoth_update_write_unittest.cpp b/update/test/hoth_update_write_unittest.cpp
new file mode 100644
index 0000000..0b4a3e6
--- /dev/null
+++ b/update/test/hoth_update_write_unittest.cpp
@@ -0,0 +1,139 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hoth_update_unittest.hpp"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ipmi_hoth
+{
+
+using ::testing::Return;
+
+class HothUpdateWriteTest : public HothUpdateTest
+{};
+
+TEST_F(HothUpdateWriteTest, InvalidSessionWriteIsRejected)
+{
+    // Verify the hoth update handler checks for a valid session.
+
+    std::vector<uint8_t> data = {0x1, 0x2};
+
+    EXPECT_FALSE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingTooMuchByOneByteFails)
+{
+    // Test the edge case of writing 1 byte too much with an offset of 0.
+    // writing hvn.maxBufferSize + 1 at offset 0 is invalid.
+
+    int bytes = hvn.maxBufferSize() + 1;
+    std::vector<uint8_t> data(0x11);
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingTooMuchByOffsetOfOne)
+{
+    // Test the edge case of writing hvn.maxBufferSize bytes (which is fine)
+    // but at the offset 1, which makes it go over by 1 byte.
+    // writing hvn.maxBufferSize + offset 1 is invalid.
+
+    int bytes = hvn.maxBufferSize();
+    std::vector<uint8_t> data(0x11);
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    // offset of 1.
+    EXPECT_FALSE(hvn.write(session_, 1, data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingOneByteBeyondEndFromOffsetFails)
+{
+    // Test the edge case of writing to the last byte offset but trying to
+    // write two bytes.
+    // writing 2 bytes at hvn.maxBufferSize - 1 is invalid.
+
+    std::vector<uint8_t> data = {0x01, 0x02};
+    ASSERT_EQ(2, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, (hvn.maxBufferSize() - 1), data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingOneByteAtOffsetBeyondEndFails)
+{
+    // Test the edge case of writing one byte but exactly one byte beyond the
+    // buffer.
+    // writing 1 byte at hvn.maxBufferSize is invalid.
+
+    std::vector<uint8_t> data = {0x01};
+    ASSERT_EQ(1, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_FALSE(hvn.write(session_, hvn.maxBufferSize(), data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingFullBufferAtOffsetZeroSucceeds)
+{
+    // Test the case where you write the full buffer length at once to the 0th
+    // offset.
+
+    int bytes = hvn.maxBufferSize();
+    std::vector<uint8_t> data = {0x01};
+    data.resize(bytes);
+    ASSERT_EQ(bytes, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.write(session_, 0, data));
+}
+
+TEST_F(HothUpdateWriteTest, WritingOneByteToTheLastOffsetSucceeds)
+{
+    // Test the case where you write the last byte.
+
+    std::vector<uint8_t> data = {0x01};
+    ASSERT_EQ(1, data.size());
+
+    EXPECT_CALL(dbus, pingHothd(std::string_view(""))).WillOnce(Return(true));
+
+    EXPECT_TRUE(hvn.open(session_, hvn.requiredFlags(), legacyPath));
+
+    EXPECT_TRUE(hvn.write(session_, (hvn.maxBufferSize() - 1), data));
+}
+
+} // namespace ipmi_hoth
diff --git a/update/test/meson.build b/update/test/meson.build
new file mode 100644
index 0000000..9cfe4f5
--- /dev/null
+++ b/update/test/meson.build
@@ -0,0 +1,20 @@
+tests = [
+  'hoth_update_unittest',
+  'hoth_update_close_unittest',
+  'hoth_update_commit_unittest',
+  'hoth_update_delete_unittest',
+  'hoth_update_open_unittest',
+  'hoth_update_read_unittest',
+  'hoth_update_stat_unittest',
+  'hoth_update_write_unittest',
+]
+
+foreach t : tests
+  test(
+    t,
+    executable(
+      t.underscorify(),
+      t + '.cpp',
+      implicit_include_directories: false,
+      dependencies: [hothupdate_dep, test_dep]))
+endforeach