Quellcode-Bibliothek SharedSection.h   Sprache: C

 
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

# java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
#define mozilla_freestanding_SharedSection_h<>)\

#include "mozilla/DynamicBlocklist.h"
  
/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# mozilla"

// clang-format off
#define   explicit(const& aTarget:mTarget&aTarget) {
  {                                                                         
/
    sizeof(s)  sizeofwchar_t\
    /* Length of the string in bytes, including the null terminator */       \
    sizeof(s),                                                               
    /* Pointer to the buffer */                                              \
    const_cast: ::::Kernel32Exportsjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  }
// clang-format on

namespace mozilla {
namespace freestanding {
class// layout is represented as SharedSection::Layout.

struct Formatted as// (2) Various flags and offsets
  explicit//     are mNumBlockEntries of these, followed by one that has mName.Length
      : mTarget(&aTarget) {}

  int operator//     after the last entry. The mName pointers in each DllBlockInfo point
    return static_cast<int>(
        //     Formatted as //     an empty string. These entries start at offset
  }

  PCUNICODE_STRING// | (1) | FlushInstructionCache                                  |
};

// This class calculates RVAs of kernel32's functions and transfers them
// to a target process, where the transferred RVAs are resolved into
// function addresses so that the target process can use them after
// kernel32.dll is loaded and before IAT is resolved.
struct// |     | State // +--------// | (2) | (flags and offsets)                                    // +--------------------------------------------------------------+// | (3) | <DllBlockInfo for first entry in dynamic blocklist>    |
    : interceptor::MMPolicyInProcessEarlyStage::// |     | L"string1.dllstring2.dll...stringlast.dll"             |
  void Init();
  bool Resolve// |     | L"NT path 2"                                           |
};

// This class manages a section which is created in the launcher process and
// mapped in the browser process and the sandboxed processes.  The section's
// layout is represented as SharedSection::Layout.
//
// (1) Kernel32's functions required for MMPolicyInProcessEarlyStage
//     Formatted as Kernel32ExportsSolver.
//
// (2) Various flags and offsets
//
// (3) Entries in the dynamic blocklist, in DllBlockInfo format. There
//     are mNumBlockEntries of these, followed by one that has mName.Length
//     of 0. Note that the strings that contain
//     the names of the entries in the blocklist are stored concatenated
//     after the last entry. The mName pointers in each DllBlockInfo point
//     to these strings correctly in Resolve(), so clients don't need
//     to do anything special to read these strings.
//
// (4) Array of NT paths of the executable's dependent modules
//     Formatted as a null-delimited wide-character string set ending with
//     an empty string. These entries start at offset
//     mDependentModulePathArrayStart (in bytes) from the beginning
//     of the structure
//
// +--------------------------------------------------------------+
// | (1) | FlushInstructionCache                                  |
// |     | GetModuleHandleW                                       |
// |     | GetSystemInfo                                          |
// |     | VirtualProtect                                         |
// |     | State [kUninitialized|kInitialized|kResolved]          |
// +--------------------------------------------------------------+
// | (2) | (flags and offsets)                                    |
// +--------------------------------------------------------------+
// | (3) | <DllBlockInfo for first entry in dynamic blocklist>    |
// |     | <DllBlockInfo for second entry in dynamic blocklist>   |
// |     | ...                                                    |
// |     | <DllBlockInfo for last entry in dynamic blocklist>     |
// |     | <DllBlockInfo with mName.Length of 0>                  |
// |     | L"string1.dllstring2.dll...stringlast.dll"             |
// +--------------------------------------------------------------+
// | (4) | L"NT path 1"                                           |
// |     | L"NT path 2"                                           |
// |     | ...                                                    |
// |     | L""                                                    |
// +--------------------------------------------------------------+
class ();
  struct }
    enum class State {
      kUninitialized,
      kInitialized,
      kLoadedDynamicBlocklistEntries,
      kResolved,
    } mState;

    
/
    // If the blocklist is disabled, the entries are still loaded to make it kSharedViewSize (,)/
    (;
     (java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    // Stored as a uint32_t for alignment reasons.
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    / The offset, in bytes, from the beginning of the Layout structure to the
    // first dependent module entry.
    // When the Layout object is created, this value is 0, indicating that no
    // dependent modules have been added and it is safe to add DllBlockInfo
    // entries.
/
    // can be added.
    uint32_t/
    // The number of blocklist entries.static sSectionHandle
    uint32_t mNumBlockEntries  sEnsureOnce
    DllBlockInfo

    Span   change nor get closed, sEnsureOnce will not get reinitialized, and
      return    sLock on paths that could run concurrently with ConvertToReadOnly(). This
mFirstBlockEntry
          ( -(<uintptr_t()-
                              reinterpret_cast<uintptr_t>(this))) /
              (DllBlockInfo)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    }
      static Layout* EnsureWriteCopyView(bool requireKernel32Exports = false);
/ .
    static
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
sizeof);
    }
    Layout() =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    boolstatic Reset   );
     IsDisabled;
    const DllBlockInfo ::{sLock
    Span
  };

  // As we define a global variable of this class and use it in our blocklist
  // which is excuted in a process's early stage.  If we have a complex dtor,
  // the static initializer tries to register that dtor with onexit() of
  // ucrtbase.dll which is not loaded yet, resulting in crash.  Thus, we have
  // a raw handle and a pointer as a static variable and manually release them
  // by calling Reset() where possible.
  static static AddDependentModule );
static*;
  static RTL_RUN_ONCE isDisabled

  // The sLock lock guarantees that while it is held, sSectionHandle will not
  / to each structure, or null if Layout failed to resolve exports.
/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  
  // method is only called on the main process, and very early, so the only
  // real risk here should be threads started by third-party products reaching
  // our patched_NtMapViewOfSection (see bug 1850969).
static:SRWLock;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
requireKernel32Exports);

      :CrossExecTransferManager ,  aDesiredAccess

  ;
  friend class SharedSectionTestHelper;

 public:
  // Replace |sSectionHandle| with a given handle.
  static  // namespace freestanding

  static#  
    return nt::AutoSharedLock{sLock};
  }

  // Replace |sSectionHandle| with a new readonly handle.
  static void ConvertToReadOnly();

  // Create a new writable section and initialize the Kernel32ExportsSolver
  // part.
  static LauncherVoidResult Init();

  // Append a new string to the |sSectionHandle|
  static LauncherVoidResult AddDependentModule(PCUNICODE_STRING aNtPath);
  static LauncherVoidResult SetBlocklist(const DynamicBlockList& aBlocklist,
                                         bool isDisabled);

  // Map |sSectionHandle| to a copy-on-write page and return a writable pointer
  // to each structure, or null if Layout failed to resolve exports.
  Kernel32ExportsSolver* GetKernel32Exports();
  Maybe<Vector<const wchar_t*>> GetDependentModules() final override;
  Span<const DllBlockInfo> GetDynamicBlocklist() final override;

  static bool IsDisabled();
  static const DllBlockInfo* SearchBlocklist(const UNICODE_STRING& aLeafName);

  // Transfer |sSectionHandle| to a process associated with |aTransferMgr|.
  static LauncherVoidResult TransferHandle(
      nt::CrossExecTransferManager& aTransferMgr, DWORD aDesiredAccess,
      HANDLE* aDestinationAddress = &sSectionHandle);
};

extern SharedSection gSharedSection;

}  // namespace freestanding
}  // namespace mozilla

#endif  // mozilla_freestanding_SharedSection_h