Bootstrap Mojo IPC independent of Chrome IPC

mojo/edk/system/node_channel.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/edk/system/node_channel.h"
 
 #include <cstring>
 #include <limits>
 #include <sstream>
 
@@ skipping 176 matching lines @@
   }
 #endif
   return ScopedPlatformHandle();
 }
 
 void NodeChannel::SetRemoteNodeName(const ports::NodeName& name) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   remote_node_name_ = name;
 }
 
+void NodeChannel::SetExpectedSecret(const std::string& secret) {
+#if !defined(OS_WIN)
+  // Ensure we aren't expecting a secret on non-Windows.
+  CHECK(secret.empty());
+#endif
+  expected_secret_ = secret;
+}
+
+void NodeChannel::SendSecret(const std::string& secret) {
+  Channel::MessagePtr message(new Channel::Message(secret.size(), 0));
+  memcpy(message->mutable_payload(), secret.data(), secret.size());
+  WriteChannelMessage(std::move(message));
+}
+
 void NodeChannel::AcceptChild(const ports::NodeName& parent_name,
                               const ports::NodeName& token) {
   AcceptChildData* data;
   Channel::MessagePtr message = CreateMessage(
       MessageType::ACCEPT_CHILD, sizeof(AcceptChildData), 0, &data);
   data->parent_name = parent_name;
   data->token = token;
   WriteChannelMessage(std::move(message));
 }
 
@@ skipping 123 matching lines @@
 
 NodeChannel::~NodeChannel() {
   ShutDown();
 }
 
 void NodeChannel::OnChannelMessage(const void* payload,
                                    size_t payload_size,
                                    ScopedPlatformHandleVectorPtr handles) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
+  if (!expected_secret_.empty()) {
+    // If we're expecting a secret string, that takes precedence over everything
+    // else.
+    if (std::string(static_cast<const char*>(payload), payload_size) !=
+        expected_secret_) {
+      LOG(ERROR) << "Received invalid secret from peer. Dropping channel.";
+      delegate_->OnChannelError(remote_node_name_);
+    }
+    expected_secret_.clear();
+    return;
+  }
+
 #if defined(OS_WIN)
   // If we receive handles from a known process, rewrite them to our own
   // process. This can occur when a privileged node receives handles directly
   // from a privileged descendant.
   {
     base::AutoLock lock(remote_process_handle_lock_);
     if (handles && remote_process_handle_ != base::kNullProcessHandle) {
       if (!Channel::Message::RewriteHandles(remote_process_handle_,
                                             base::GetCurrentProcessHandle(),
                                             handles->data(), handles->size())) {
@@ skipping 192 matching lines @@
 
   base::AutoLock lock(channel_lock_);
   if (!channel_)
     DLOG(ERROR) << "Dropping message on closed channel.";
   else
     channel_->Write(std::move(message));
 }
 
 }  // namespace edk
 }  // namespace mojo