TestWindowsHandleValidation.cpp

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gtest/gtest.h"

#include <windows.h>

#include "chrome/common/ipc_channel.h"

#include "chrome/common/ipc_channel_win.h"

#include "mozilla/Preferences.h"

#include "mozilla/UniquePtrExtensions.h"

#include "mozilla/ipc/CrossProcessMutex.h"

#include "mozilla/ipc/CrossProcessSemaphore.h"

#include "mozilla/ipc/SharedMemoryHandle.h"

namespace mozilla::ipc {

// Like DuplicateFileHandle, but doesn't refuse to duplicate pseudo-handles like

// ::GetCurrentProcess() (because ::GetCurrentProcess() ==

// INVALID_HANDLE_VALUE).

static UniqueFileHandle DuplicatePseudoHandle(HANDLE aHandle) {

  HANDLE duplicated = INVALID_HANDLE_VALUE;

  BOOL ok =

      ::DuplicateHandle(::GetCurrentProcess(), aHandle, ::GetCurrentProcess(),

                        &duplicated, 0, false, DUPLICATE_SAME_ACCESS);

  EXPECT_TRUE(ok);

  return UniqueFileHandle(duplicated);

TEST(TestWindowsHandleValidation, RejectProcess)

  EXPECT_FALSE(IPC::ChannelWin::IsAllowedHandleType(::GetCurrentProcess()));

  UniqueFileHandle process = DuplicatePseudoHandle(::GetCurrentProcess());

  ASSERT_TRUE(process);

  EXPECT_FALSE(IPC::ChannelWin::IsAllowedHandleType(process.get()));

TEST(TestWindowsHandleValidation, RejectThread)

  EXPECT_FALSE(IPC::ChannelWin::IsAllowedHandleType(::GetCurrentThread()));

  UniqueFileHandle thread = DuplicatePseudoHandle(::GetCurrentThread());

  ASSERT_TRUE(thread);

  EXPECT_FALSE(IPC::ChannelWin::IsAllowedHandleType(thread.get()));

TEST(TestWindowsHandleValidation, AllowSharedMemoryHandles)

  MutableSharedMemoryHandle shmem = shared_memory::Create(1);

  ASSERT_TRUE(shmem);

  UniqueFileHandle handle = std::move(shmem).TakePlatformHandle();

  ASSERT_TRUE(handle);

  EXPECT_TRUE(IPC::ChannelWin::IsAllowedHandleType(handle.get()));

TEST(TestWindowsHandleValidation, AllowCrossProcessMutexHandles)

  mozilla::CrossProcessMutex mutex("TestWindowsHandleValidation");

  UniqueFileHandle handle = mutex.CloneHandle();

  ASSERT_TRUE(handle);

  EXPECT_TRUE(IPC::ChannelWin::IsAllowedHandleType(handle.get()));

TEST(TestWindowsHandleValidation, AllowCrossProcessSemaphoreHandles)

  UniquePtr<mozilla::CrossProcessSemaphore> semaphore(

      mozilla::CrossProcessSemaphore::Create("TestWindowsHandleValidation", 0));

  ASSERT_TRUE(semaphore);

  UniqueFileHandle handle = semaphore->CloneHandle();

  ASSERT_TRUE(handle);

  EXPECT_TRUE(IPC::ChannelWin::IsAllowedHandleType(handle.get()));

TEST(TestWindowsHandleValidation, AllowRawPipeHandles)

  IPC::Channel::ChannelHandle server;

  IPC::Channel::ChannelHandle client;

  ASSERT_TRUE(IPC::ChannelWin::sKind.create_raw_pipe(&server, &client));

  ASSERT_TRUE(std::holds_alternative<UniqueFileHandle>(server));

  UniqueFileHandle serverHandle = std::get<UniqueFileHandle>(std::move(server));

  ASSERT_TRUE(serverHandle);

  EXPECT_TRUE(IPC::ChannelWin::IsAllowedHandleType(serverHandle.get()));

  ASSERT_TRUE(std::holds_alternative<UniqueFileHandle>(client));

  UniqueFileHandle clientHandle = std::get<UniqueFileHandle>(std::move(client));

  ASSERT_TRUE(clientHandle);

  EXPECT_TRUE(IPC::ChannelWin::IsAllowedHandleType(clientHandle.get()));

}  // namespace mozilla::ipc