Add SetCapabilities for setting capabilities to an exact set.

sandbox/linux/services/credentials.cc

 // Copyright (c) 2013 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 "sandbox/linux/services/credentials.h"
 
 #include <errno.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/capability.h>
@@ skipping 135 matching lines @@
   CHECK(!HasAnyCapability());
   // We never let this function fail.
   return true;
 }
 
 bool Credentials::DropAllCapabilities() {
   base::ScopedFD proc_fd(ProcUtil::OpenProc());
   return Credentials::DropAllCapabilities(proc_fd.get());
 }
 
+// static
+bool Credentials::SetCapabilities(int proc_fd,
+                                  const std::vector<cap_value_t>& caps) {
+  DCHECK_LE(0, proc_fd);

[jln (very slow on Chromium), 2015/03/10 17:03:34]

if (caps.size <= 0) return false;

[jln (very slow on Chromium), 2015/03/10 17:03:34]

if (caps.size <= 0) return false;

[rickyz (no longer on Chrome), 2015/03/10 20:22:13]

Oops, that's embarrassing - I placed the cap_set_flag loop inside an if instead
so that callers can pass an empty list.

+  CHECK(ThreadHelpers::IsSingleThreaded(proc_fd));
+
+  sandbox::ScopedCap cap(cap_init());
+  PCHECK(cap != nullptr);
+  cap_flag_t flags[] = {CAP_EFFECTIVE, CAP_PERMITTED};

[jln (very slow on Chromium), 2015/03/10 17:03:34]

Why not include CAP_INHERITABLE ? It seems much safer and I can't think of any
drawback since we're not using file capabilities anywhere.

[rickyz (no longer on Chrome), 2015/03/10 20:22:13]

Isn't not including CAP_INHERITABLE slightly more restrictive/safer?

[jln (very slow on Chromium), 2015/03/10 22:12:11]

You're right that we don't want to set any cap in CAP_INHERITABLE, but we should
make sure that CAP_INHERITABLE is empty. Otherwise using SetCapabilities to
"drop privileges" isn't necessarily dropping everything.

[jln (very slow on Chromium), 2015/03/10 22:18:40]

Ok, forget that: of course CAP_INHERITABLE is *already* empty after cap_init.

Maybe add a comment?

[rickyz (no longer on Chrome), 2015/03/10 22:22:14]

Done.

+  for (const cap_flag_t flag : flags) {
+    PCHECK(cap_set_flag(cap.get(), flag, caps.size(), &caps[0], CAP_SET) == 0);

[jln (very slow on Chromium), 2015/03/10 17:03:35]

caps.at(0) instead of caps[0] for good measure?

[rickyz (no longer on Chrome), 2015/03/10 20:22:14]

Done.

+  }
+  return cap_set_proc(cap.get()) == 0;
+}
+
 bool Credentials::HasAnyCapability() {
   ScopedCap current_cap(cap_get_proc());
   CHECK(current_cap);
   ScopedCap empty_cap(cap_init());
   CHECK(empty_cap);
   return cap_compare(current_cap.get(), empty_cap.get()) != 0;
 }
 
+bool Credentials::HasCapability(cap_value_t cap) {
+  ScopedCap current_cap(cap_get_proc());
+  PCHECK(current_cap);
+
+  cap_flag_value_t value;
+  PCHECK(cap_get_flag(current_cap.get(), cap, CAP_EFFECTIVE, &value) == 0);

[jln (very slow on Chromium), 2015/03/10 17:03:34]

Let's do a for() loop like above instead? It's more readable.

[rickyz (no longer on Chrome), 2015/03/10 20:22:14]

Done.

+  if (value != CAP_SET) {
+    PCHECK(cap_get_flag(current_cap.get(), cap, CAP_PERMITTED, &value) == 0);
+  }
+
+  return value == CAP_SET;
+}
+
 scoped_ptr<std::string> Credentials::GetCurrentCapString() {
   ScopedCap current_cap(cap_get_proc());
   CHECK(current_cap);
   ScopedCapText cap_text(cap_to_text(current_cap.get(), NULL));
   CHECK(cap_text);
   return scoped_ptr<std::string> (new std::string(cap_text.get()));
 }
 
 // static
 bool Credentials::CanCreateProcessInNewUserNS() {
@@ skipping 71 matching lines @@
   CHECK_LE(0, proc_fd);
 
   CHECK(ChrootToSafeEmptyDir());
   CHECK(!base::DirectoryExists(base::FilePath("/proc")));
   CHECK(!ProcUtil::HasOpenDirectory(proc_fd));
   // We never let this function fail.
   return true;
 }
 
 }  // namespace sandbox.