Fixing a couple of issues in sandbox::RestrictedToken:

sandbox/win/src/restricted_token.cc

 // Copyright (c) 2006-2008 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/win/src/restricted_token.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "sandbox/win/src/acl.h"
 #include "sandbox/win/src/win_utils.h"
 
 
 namespace sandbox {
 
 unsigned RestrictedToken::Init(const HANDLE effective_token) {
   DCHECK(!init_);
   if (init_)
     return ERROR_ALREADY_INITIALIZED;
 
   if (effective_token) {
     // We duplicate the handle to be able to use it even if the original handle
     // is closed.
     HANDLE effective_token_dup;
     if (::DuplicateHandle(::GetCurrentProcess(),
                           effective_token,
                           ::GetCurrentProcess(),
                           &effective_token_dup,
-                          DUPLICATE_SAME_ACCESS,
+                          0,
                           FALSE,
-                          0)) {  // no special options
+                          DUPLICATE_SAME_ACCESS)) {
       effective_token_ = effective_token_dup;
     } else {
       return ::GetLastError();
     }
   } else {
     if (!::OpenProcessToken(::GetCurrentProcess(),
                             TOKEN_ALL_ACCESS,
                             &effective_token_))
       return ::GetLastError();
   }
@@ skipping 214 matching lines @@
 
   DWORD size = sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE;
   TOKEN_USER* token_user = reinterpret_cast<TOKEN_USER*>(new BYTE[size]);
 
   BOOL result = ::GetTokenInformation(effective_token_,
                                       TokenUser,
                                       token_user,
                                       size,
                                       &size);
 
+  if (!result) {
+    delete[] reinterpret_cast<BYTE*>(token_user);
+    return ::GetLastError();
+  }
+
   Sid user = reinterpret_cast<SID*>(token_user->User.Sid);
+  sids_for_deny_only_.push_back(user);
+
   delete[] reinterpret_cast<BYTE*>(token_user);
 
-  if (!result)
-    return ::GetLastError();
-
-  sids_for_deny_only_.push_back(user);
   return ERROR_SUCCESS;
 }
 
 unsigned RestrictedToken::DeleteAllPrivileges(
     const std::vector<std::wstring> *exceptions) {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   // Get the list of privileges in the token
@@ skipping 33 matching lines @@
           break;
         }
       }
     }
     if (!should_ignore) {
         privileges_to_disable_.push_back(token_privileges->Privileges[i].Luid);
     }
   }
 
   delete[] reinterpret_cast<BYTE *>(token_privileges);
+
   return ERROR_SUCCESS;
 }
 
 unsigned RestrictedToken::DeletePrivilege(const wchar_t *privilege) {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   LUID luid = {0};
   if (LookupPrivilegeValue(NULL, privilege, &luid))
@@ skipping 63 matching lines @@
 
   DWORD size = sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE;
   TOKEN_USER* token_user = reinterpret_cast<TOKEN_USER*>(new BYTE[size]);
 
   BOOL result = ::GetTokenInformation(effective_token_,
                                       TokenUser,
                                       token_user,
                                       size,
                                       &size);
 
+  if (!result) {
+    delete[] reinterpret_cast<BYTE*>(token_user);
+    return ::GetLastError();
+  }
+
   Sid user = reinterpret_cast<SID*>(token_user->User.Sid);
+  sids_to_restrict_.push_back(user);
+
   delete[] reinterpret_cast<BYTE*>(token_user);
 
-
-  if (!result)
-    return ::GetLastError();
-
-  sids_to_restrict_.push_back(user);
   return ERROR_SUCCESS;
 }
 
 unsigned RestrictedToken::AddRestrictingSidAllSids() {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   // Add the current user to the list.
   unsigned error = AddRestrictingSidCurrentUser();
@@ skipping 30 matching lines @@
 
   return ERROR_SUCCESS;
 }
 
 unsigned RestrictedToken::SetIntegrityLevel(IntegrityLevel integrity_level) {
   integrity_level_ = integrity_level;
   return ERROR_SUCCESS;
 }
 
 }  // namespace sandbox