[login_manager] Prevent non-children from calling RestartJob

session_manager_service.cc

 // Copyright (c) 2009-2010 The Chromium OS 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 "login_manager/session_manager_service.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <errno.h>
 #include <glib.h>
 #include <grp.h>
@@ skipping 188 matching lines @@
                    G_TYPE_NONE,     // return type
                    2,               // num params
                    G_TYPE_STRING,   // state ("started" or "stopped")
                    G_TYPE_STRING);  // current user
 
   if (!store_->LoadOrCreate())
     LOG(ERROR) << "Could not load existing settings.  Continuing anyway...";
   return Reset();
 }
 
+bool SessionManagerService::Register(
+    const chromeos::dbus::BusConnection &connection) {
+  if (!chromeos::dbus::AbstractDbusService::Register(connection))
+    return false;
+  const std::string filter =
+      StringPrintf("type='method_call', interface='%s'", service_interface());
+  DBusConnection* conn =
+      ::dbus_g_connection_get_connection(connection.g_connection());
+  CHECK(conn);
+  DBusError error;
+  ::dbus_error_init(&error);
+  ::dbus_bus_add_match(conn, filter.c_str(), &error);
+  if (::dbus_error_is_set(&error)) {
+    LOG(WARNING) << "Failed to add match to bus: " << error.name << ", message="
+                 << (error.message ? error.message : "unknown error");
+    return false;
+  }
+  if (!::dbus_connection_add_filter(conn,
+                                    &SessionManagerService::FilterMessage,
+                                    this,
+                                    NULL)) {
+    LOG(WARNING) << "Failed to add filter to connection";
+    return false;
+  }
+  return true;
+}
+
 bool SessionManagerService::Reset() {
   if (session_manager_)
     g_object_unref(session_manager_);
   session_manager_ =
       reinterpret_cast<gobject::SessionManager*>(
           g_object_new(gobject::session_manager_get_type(), NULL));
 
   // Allow references to this instance.
   session_manager_->service = this;
 
@@ skipping 86 matching lines @@
     exit(1);  // Run() is not supposed to return.
   }
   g_child_watch_add_full(G_PRIORITY_HIGH_IDLE,
                          pid,
                          HandleChildExit,
                          this,
                          NULL);
   return pid;
 }
 
+bool SessionManagerService::IsKnownChild(int pid) {
+  return std::find(child_pids_.begin(), child_pids_.end(), pid) !=
+      child_pids_.end();
+}
+
 void SessionManagerService::AllowGracefulExit() {
   shutting_down_ = true;
   if (exit_on_child_done_) {
     g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
                     ServiceShutdown,
                     this,
                     NULL);
   }
 }
 
@@ skipping 476 matching lines @@
   if (at == string::npos)
     return false;
 
   // it has more than one @.
   if (email_address.find(kEmailSeparator, at+1) != string::npos)
     return false;
 
   return true;
 }
 
+// static
+DBusHandlerResult SessionManagerService::FilterMessage(DBusConnection* conn,
+                                                       DBusMessage* message,
+                                                       void* data) {
+  SessionManagerService* service = static_cast<SessionManagerService*>(data);
+  if (::dbus_message_is_method_call(message,
+                                    service->service_interface(),
+                                    kSessionManagerRestartJob)) {
+    const char* sender = ::dbus_message_get_sender(message);
+    if (!sender) {
+      LOG(ERROR) << "Call to RestartJob has no sender";
+      return DBUS_HANDLER_RESULT_HANDLED;
+    }
+    LOG(INFO) << "Received RestartJob from " << sender;
+    DBusMessage* get_pid =
+        ::dbus_message_new_method_call("org.freedesktop.DBus",
+                                       "/org/freedesktop/DBus",
+                                       "org.freedesktop.DBus",
+                                       "GetConnectionUnixProcessID");
+    CHECK(get_pid);
+    ::dbus_message_append_args(get_pid,
+                               DBUS_TYPE_STRING, &sender,
+                               DBUS_TYPE_INVALID);
+    DBusMessage* got_pid =
+        ::dbus_connection_send_with_reply_and_block(conn, get_pid, -1, NULL);
+    ::dbus_message_unref(get_pid);
+    if (!got_pid) {
+      LOG(ERROR) << "Could not look up sender of RestartJob";
+      return DBUS_HANDLER_RESULT_HANDLED;
+    }
+    uint32 pid;
+    if (!::dbus_message_get_args(got_pid, NULL,
+                                 DBUS_TYPE_UINT32, &pid,
+                                 DBUS_TYPE_INVALID)) {
+      ::dbus_message_unref(got_pid);
+      LOG(ERROR) << "Could not extract pid of sender of RestartJob";
+      return DBUS_HANDLER_RESULT_HANDLED;
+    }
+    ::dbus_message_unref(got_pid);
+    if (!service->IsKnownChild(pid)) {
+      LOG(WARNING) << "Sender of RestartJob is no child of mine!";
+      return DBUS_HANDLER_RESULT_HANDLED;
+    }
+  }
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
 void SessionManagerService::SetupHandlers() {
   // I have to ignore SIGUSR1, because Xorg sends it to this process when it's
   // got no clients and is ready for new ones.  If we don't ignore it, we die.
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIG_IGN;
   CHECK(sigaction(SIGUSR1, &action, NULL) == 0);
 
   action.sa_handler = SessionManagerService::do_nothing;
   CHECK(sigaction(SIGALRM, &action, NULL) == 0);
@@ skipping 177 matching lines @@
 
 gboolean SessionManagerService::GetPropertyHelper(const std::string& name,
                                                   std::string* OUT_value,
                                                   std::string* OUT_signature,
                                                   GError** error) {
   std::string encoded;
   if (!store_->Get(name, OUT_value, &encoded)) {
     std::string error_string =
         base::StringPrintf("The requested property %s is unknown.",
                            name.c_str());
-    LOG(INFO) << error_string;
     SetGError(error,
               CHROMEOS_LOGIN_ERROR_UNKNOWN_PROPERTY,
               error_string.c_str());
     return FALSE;
   }
   if (!base::Base64Decode(encoded, OUT_signature)) {
     SetGError(error,
               CHROMEOS_LOGIN_ERROR_DECODE_FAIL,
               "Signature could not be decoded.");
     return FALSE;
@@ skipping 16 matching lines @@
       arg_list.push_back(args[i_arg]);
     }
   }
   if (arg_list.size()) {
     arg_lists.push_back(arg_list);
   }
   return arg_lists;
 }
 
 }  // namespace login_manager