如何使用 Boost Interprocess 在服务和用户程序之间安全地通信？

Question

我有一个具有 LOCAL SYSTEM 权限的服务，我希望它能够与我的客户端应用程序通信，该应用程序在非特权用户下运行（我在 Windows 上）。 我将 boost::interprocess 用于“共享内存”，它实际上只是在后台创建内存映射文件。 现在我只是简单地创建一个内存映射文件，并将 GENERIC_READ 和 GENERIC_WRITE 提供给每个人，以便客户端可以与服务通信。 但是，我想知道当前的安全风险是什么，以及如何确保安全？

一方面，有人可能会覆盖内存映射文件中的数据，从而中断客户端和服务之间的通信。 但我想知道是否有可能发生更激烈的事情，比如有人通过编辑内存映射文件将服务重定向到其他内存地址以执行恶意代码。 我不在内存映射文件本身中存储指针，我只使用 boost::interprocess offset_ptr 和纯数据。

Answer 1

是的，篡改您的共享内存的人可能会危及大多数应用程序。

不，使用offset_ptr不会对此产生影响。

• 作为一个简单的反例，想象一个使用offset_ptr的链表或图形。 如果恶意行为者在该列表中创建了一个循环，那么如果您的应用程序没有对此进行保护，它可能会通过无限循环导致 DoS。

• offset_ptr仅允许将指针值解释为单独进程空间中的等效地址，但它不提供对实际值的验证。 一个简单的反例是当您将指针指向共享内存区域的有效范围之外时。 使用offset_ptr存储它并不重要，指针值仍然无效。

访问控制

您似乎追求的是访问控制。 这很难实现，因此在 Boost Interprocess 中仅存在有限的控制，形式为boost::interprocess::permissions ：

// In header: <boost/interprocess/permissions.hpp>


class permissions {
public:
  // construct/copy/destruct
  permissions(os_permissions_type) noexcept;
  permissions() noexcept;

  // public member functions
  void set_default() noexcept;
  void set_unrestricted() noexcept;
  void set_permissions(os_permissions_type) noexcept;
  os_permissions_type get_permissions() const noexcept;
};

默认权限是 Windows 上的空SECURITY_ATTRIBUTES或 POSIX 上的644文件模式 (u=rw,go=r)。

要在 linux 上限制所有者（实际上是创建共享内存对象的用户）的读写访问，请使用例如0600 。

演示

科利鲁

#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/permissions.hpp>
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <mutex>

// demo data structure
#include <boost/container/static_vector.hpp>
#include <boost/range/iterator_range.hpp>
#include <fmt/ranges.h>

namespace bip = boost::interprocess;
namespace bc = boost::container;

struct SharedData {
    struct Layout {
        using Lock = std::unique_lock<bip::interprocess_mutex>;

        bip::interprocess_mutex mutable mutex_;
        bc::static_vector<int, 1024> vec_{};

        Lock obtainLock() const { return Lock(mutex_); }

        void add(int i) {
            auto lk = obtainLock();
            vec_.push_back(i);
        }
    };

    bip::shared_memory_object _smo = [] {
        bip::permissions          _perms{0600}; // u=rw
        bip::shared_memory_object smo(bip::open_or_create, "demo_shared",
                                      bip::mode_t::read_write, _perms);
        smo.truncate(sizeof(Layout));
        return smo;
    }();
    bip::mapped_region _mr{_smo, bip::mode_t::read_write, 0, sizeof(Layout)};

    void add(int i) { raw().add(i); }
    auto list() {
        auto lk = raw().obtainLock();
        return std::make_pair(std::move(lk),
                              boost::make_iterator_range(raw().vec_));
    }

  private:
    Layout& raw() { return *reinterpret_cast<Layout*>(_mr.get_address()); }
};

int main(int argc, char** argv) {
    auto const addable = std::vector(argv + 1, argv + argc);
    SharedData data;

    auto dump = [&data] {
        auto [lk, ls] = data.list();
        fmt::print("Existing: {}\n", ls);
    };

    dump();

    for (auto i : addable)
    {
        fmt::print("Adding element: {}\n", i);
        data.add(std::stoi(i));

        dump();
    }
}

当运行例如sotest 1 2 3打印例如

$ ./build/sotest 1
Existing: []
Adding element: 1
Existing: [1]

$ ./build/sotest 2 3 4
Existing: [1]
Adding element: 2
Existing: [1, 2]
Adding element: 3
Existing: [1, 2, 3]
Adding element: 4
Existing: [1, 2, 3, 4]

并且共享内存模式是-rw------- ：

stat /dev/shm/demo_shared 
  File: /dev/shm/demo_shared
  Size: 4144            Blocks: 16         IO Block: 4096   regular file
Device: 18h/24d Inode: 29          Links: 1
Access: (0600/-rw-------)  Uid: ( 2000/    sehe)   Gid: ( 2000/    sehe)
Access: 2022-06-28 00:25:47.167492907 +0200
Modify: 2022-06-28 00:25:10.559796466 +0200
Change: 2022-06-28 00:25:10.559796466 +0200
 Birth: -