1. Create a new sandbox type which allows access to Unix sockets in the Mac...

chrome/common/sandbox_mac.mm

 // Copyright (c) 2009 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 "chrome/common/sandbox_mac.h"
 
 #include "base/debug_util.h"
 
 #import <Cocoa/Cocoa.h>
 extern "C" {
 #include <sandbox.h>
 }
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/mac_util.h"
+#include "base/rand_util_c.h"
 #include "base/scoped_cftyperef.h"
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/string16.h"
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "unicode/uchar.h"
 
 namespace {
@@ skipping 199 matching lines @@
   {  // CGImageSourceGetStatus() - 10.6
      // Create a png with just enough data to get everything warmed up...
     char png_header[] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
     NSData* data = [NSData dataWithBytes:png_header
                                   length:arraysize(png_header)];
     scoped_cftyperef<CGImageSourceRef> img(
         CGImageSourceCreateWithData((CFDataRef)data,
         NULL));
     CGImageSourceGetStatus(img);
   }
+
+  { // Native Client access to /dev/random.
+    GetUrandomFD();
+  }
 }
 
 // Turns on the OS X sandbox for this process.
 bool EnableSandbox(SandboxProcessType sandbox_type,
                    const FilePath& allowed_dir) {
   // Sanity - currently only SANDBOX_TYPE_UTILITY supports a directory being
   // passed in.
   if (sandbox_type != SANDBOX_TYPE_UTILITY) {
     DCHECK(allowed_dir.empty())
         << "Only SANDBOX_TYPE_UTILITY allows a custom directory parameter.";
   }
   // We use a custom sandbox definition file to lock things down as
   // tightly as possible.
   // TODO(jeremy): Look at using include syntax to unify common parts of sandbox
   // definition files.
   NSString* sandbox_config_filename = nil;
+  bool allow_nacl_lines = false;
   switch (sandbox_type) {
     case SANDBOX_TYPE_RENDERER:
       sandbox_config_filename = @"renderer";
       break;
     case SANDBOX_TYPE_WORKER:
       sandbox_config_filename = @"worker";
       break;
     case SANDBOX_TYPE_UTILITY:
       sandbox_config_filename = @"utility";
       break;
+    case SANDBOX_TYPE_NACL_PLUGIN:
+      // The Native Client plugin is a standard renderer sandbox with some
+      // additional lines to support use of Unix sockets.
+      // TODO(msneck): Remove the use of Unix sockets from Native Client and
+      // then remove the associated rules from chrome/renderer/renderer.sb.
+      // See http://code.google.com/p/nativeclient/issues/detail?id=344
+      sandbox_config_filename = @"renderer";
+      allow_nacl_lines = true;
+      break;
+    case SANDBOX_TYPE_NACL_LOADER:
+      // The Native Client loader is used for safeguarding the user's
+      // untrusted code within Native Client.
+      // TODO(msneck): Remove the use of Unix sockets from Native Client and
+      // then decide on an appropriate sandbox type for the untrusted code.
+      // This might simply mean removing the Unix socket rules from
+      // chrome/browser/nacl-loader.sb or it might mean sharing the
+      // sandbox configuration with SANDBOX_TYPE_WORKER.
+      // See http://code.google.com/p/nativeclient/issues/detail?id=344
+      sandbox_config_filename = @"nacl-loader";
+      break;
     default:
       NOTREACHED();
       return false;
   }
 
   NSString* sandbox_profile_path =
       [mac_util::MainAppBundle() pathForResource:sandbox_config_filename
                                           ofType:@"sb"];
   NSString* sandbox_data = [NSString
       stringWithContentsOfFile:sandbox_profile_path
                       encoding:NSUTF8StringEncoding
                          error:nil];
 
   if (!sandbox_data) {
     PLOG(ERROR) << "Failed to find the sandbox profile on disk "
                 << base::SysNSStringToUTF8(sandbox_profile_path);
     return false;
   }
 
   // Enable verbose logging if enabled on the command line.
   // (see renderer.sb for details).
   const CommandLine *command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableSandboxLogging)) {
     sandbox_data = [sandbox_data
         stringByReplacingOccurrencesOfString:@";ENABLE_LOGGING"
                                   withString:@""];
   }
 
+  // Enable Native Client lines if they are allowed.
+  if (allow_nacl_lines) {
+    sandbox_data = [sandbox_data
+        stringByReplacingOccurrencesOfString:@";NACL"
+                                  withString:@""];
+  }
+
   if (!allowed_dir.empty()) {
     // The sandbox only understands "real" paths.  This resolving step is
     // needed so the caller doesn't need to worry about things like /var
     // being a link to /private/var (like in the paths CreateNewTempDirectory()
     // returns).
     FilePath allowed_dir_absolute(allowed_dir);
     if (!file_util::AbsolutePath(&allowed_dir_absolute)) {
       PLOG(ERROR) << "Failed to resolve absolute path";
       return false;
     }
@@ skipping 33 matching lines @@
     std::string home_dir = base::SysNSStringToUTF8(NSHomeDirectory());
     std::string home_dir_escaped;
     if (!QuotePlainString(home_dir, &home_dir_escaped)) {
       LOG(ERROR) << "Sandbox string quoting failed";
       return false;
     }
     NSString* home_dir_escaped_ns = base::SysUTF8ToNSString(home_dir_escaped);
     sandbox_data = [sandbox_data
         stringByReplacingOccurrencesOfString:@"USER_HOMEDIR"
                                   withString:home_dir_escaped_ns];
+  } else if (major_version == 10 && minor_version < 6) {
+    // Sandbox rules only for versions before 10.6.
+    sandbox_data = [sandbox_data
+        stringByReplacingOccurrencesOfString:@";BEFORE_10.6"
+                                  withString:@""];
   }
 
   char* error_buff = NULL;
   int error = sandbox_init([sandbox_data UTF8String], 0, &error_buff);
   bool success = (error == 0 && error_buff == NULL);
   LOG_IF(ERROR, !success) << "Failed to initialize sandbox: "
                           << error
                           << " "
                           << error_buff;
   sandbox_free_error(error_buff);
   return success;
 }
 
 }  // namespace sandbox