public static void VirtualMemorySetProtection(void* pointer, IntPtr size, MemoryProtection protection)
{
int old;
switch (protection)
{
case MemoryProtection.Execute:
Kernel32.VirtualProtect(pointer, size, Kernel32.VirtualMemProtectionFlag.PageExecute, out old);
break;
case MemoryProtection.ReadWrite:
Kernel32.VirtualProtect(pointer, size, Kernel32.VirtualMemProtectionFlag.PageReadWrite, out old);
break;
}
}
public MemoryMappedFileStream(string name, uint maxLength, MemoryProtection protection)
{
if(string.IsNullOrEmpty(name))
{
throw(new ArgumentException("Argument_Name"));
}
if(maxLength < 0)
{
throw(new ArgumentOutOfRangeException("ArgumentOutOfRange_MaxLength"));
}
objectName = name;
if (protection < MemoryProtection.PageNoAccess ||
protection > MemoryProtection.SecReserve)
{
throw new ArgumentOutOfRangeException("ArgumentOutOfRange_Enum");
}
if( maxLength == 0 )
{
mapLength = 5120;
}
else
{
mapLength = maxLength;
}
memProtection = protection;
isReadable = true;
isWritable = true;
isSeekable = true;
// Initialize mapViewPointer
mapViewPointer = new IntPtr(-1);
SECURITY_ATTRIBUTES sa = SECURITY_ATTRIBUTES.GetNullDacl();
try
{
mapHandle = MemoryMappedFileHelper.CreateFileMapping(
IntPtr.Zero,
sa,
memProtection,
0,
mapLength,
objectName);
}
finally
{
Marshal.FreeHGlobal(sa.lpSecurityDescriptor);
sa.lpSecurityDescriptor = IntPtr.Zero;
}
if(mapHandle == IntPtr.Zero )
{
uint lastError = MemoryMappedFileHelper.GetLastError();
throw new IOException(
MemoryMappedFileHelper.GetWin32ErrorMessage( lastError ) );
}
}
public PhysicalPagesMapping Map(IntPtr address, MemoryProtection protection)
{
IntPtr allocAddress = ProcessHandle.Current.AllocateMemory(
address,
_count * Windows.PageSize,
MemoryFlags.Reserve | MemoryFlags.Physical,
protection
);
if (!Win32.MapUserPhysicalPages(
allocAddress,
new IntPtr(_count),
_pfnArray
))
Win32.ThrowLastError();
return new PhysicalPagesMapping(this, allocAddress);
}
static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
internal static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, MemoryProtection flNewProtect, ref MemoryProtection lpflOldProtect);
public static extern bool VirtualProtectEx( IntPtr hProcess, IntPtr lpAddress, uint dwSize, MemoryProtection flNewProtect, [Out] MemoryProtection lpflOldProtect);
public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
int dwSize, MemoryProtection prot, out MemoryProtection oldProt);
public static extern IntPtr VirtualAlloc(IntPtr blockAddress, UIntPtr sizeInBytes,
MemoryAllocationType allocationType, MemoryProtection protection);
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
private static extern UIntPtr VirtualAlloc(
UIntPtr lpAddress,
UIntPtr dwSize,
AllocationType flAllocationType,
MemoryProtection flProtect);
internal MemoryProtection ProtectVirtualMemory(IntPtr baseAddress, int protectionSize, MemoryProtection protectionType)
{
if (!VirtualProtectEx(_processHandle, baseAddress, protectionSize, protectionType, out var oldProtectionType))
{
ExceptionHandler.ThrowWin32Exception("Failed to protect a region of virtual memory in the remote process");
}
return(oldProtectionType);
}
private static extern IntPtr VirtualAlloc(UInt32 lpStartAddr, UInt32 size, UInt32 flAllocationType, MemoryProtection flProtect);
public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, int nSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
/// <summary>
/// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process.
/// Memory allocated by this function is automatically initialized to zero.
/// </summary>
/// <param name="sizeInBytes">The size of the region, in bytes</param>
/// <param name="allocationType">The type of memory allocation.</param>
/// <param name="protection">The memory protection for the region of pages to be allocated.</param>
/// <returns>The base address of the allocated region of pages.</returns>
public static void* VirtualAlloc(ulong sizeInBytes, MemoryAllocationType allocationType, MemoryProtection protection)
{
var pointer = VirtualAlloc(IntPtr.Zero, new UIntPtr(sizeInBytes), allocationType, protection).ToPointer();
if (pointer == null)
throw new InvalidOperationException(Marshal.GetLastWin32Error().ToString());
return pointer;
}
public static int mprotect(IntPtr addr, UIntPtr len, MemoryProtection prot) => mprotect(addr, len, (int)prot);
private static extern bool __VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
UIntPtr dwSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
static extern IntPtr VirtualAllocEx(IntPtr hProcess,
IntPtr lpAddress,
int dwSize,
AllocationType flAllocationType,
MemoryProtection flProtect);
public static void VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
UIntPtr dwSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect)
{
if (!__VirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect, out lpflOldProtect))
{
throw new Win32Exception();
}
}
public static void VirtualMemorySetProtection(void* pointer, IntPtr size, MemoryProtection protection)
{
NativeUtilsImplementation.VirtualMemorySetProtection(pointer, size, protection);
}
public static extern int VirtualAllocEx(IntPtr hProcess, Int32 lpAddress,
Int32 dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public void Protect(SafeProcessHandle handle, uint offset, uint size, MemoryProtection newProtect)
{
if (Address == IntPtr.Zero)
throw new ObjectDisposedException("RemoteMemoryRegion");
if ((offset + size) > (Size))
throw new ArgumentException("Size too large for region");
MemoryProtection oldProtect;
int result = Win32.VirtualProtectEx(
handle.DangerousGetHandle(),
(uint)(Address.ToInt64() + offset),
size, newProtect, out oldProtect
);
if (result == 0) {
var error = Win32.GetLastError();
throw new Exception(String.Format("Protect failed: Error {0:x8}", error));
}
}
public static IntPtr Alloc(Int32 size, MemoryProtection protection, AllocationType allocationType)
{
return(Memory.Alloc(IntPtr.Zero, size, protection, allocationType));
}
public static extern DWORD_PTR VirtualAllocEx( IntPtr hProcess, DWORD_PTR lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect );
public static IntPtr Alloc(IntPtr address, Int32 size, MemoryProtection protection, AllocationType allocationType)
{
return(Kernel32.VirtualAlloc(address, size, allocationType, protection));
}
public PhysicalPagesMapping Map(MemoryProtection protection)
{
return this.Map(IntPtr.Zero, protection);
}
public static IntPtr Alloc(Int32 size, MemoryProtection protection)
{
return(Memory.Alloc(size, protection, AllocationType.Commit));
}
public static Win32FileMapAccess GetWin32FileMapAccess(
MemoryProtection protection )
{
switch ( protection )
{
case MemoryProtection.PageReadOnly:
return Win32FileMapAccess.FILE_MAP_READ;
case MemoryProtection.PageWriteCopy:
return Win32FileMapAccess.FILE_MAP_WRITE;
default:
return Win32FileMapAccess.FILE_MAP_ALL_ACCESS;
}
}
public static extern ulong VirtualAllocEx(IntPtr hProcess, ulong lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
internal static extern IntPtr VirtualAllocEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType,
MemoryProtection flProtect);
public SafeVirtualMemoryHandle(IntPtr processHandle, Int64 address, Int64 size, AllocationType allocation, MemoryProtection protection)
: base(true)
{
_processHandle = processHandle;
_size = size;
handle = Kernel32.VirtualAllocEx(processHandle, (IntPtr)address, (IntPtr)_size, allocation, protection);
if (IsInvalid)
{
throw new Win32Exception();
}
}
public static IntPtr mmap(IntPtr addr, UIntPtr length, MemoryProtection prot, int flags, int fd, IntPtr offset) => mmap(addr, length, (int)prot, flags, fd, offset);
private static extern IntPtr VirtualAllocEx(SafeMemoryHandle hProcess, IntPtr lpAddress,
UIntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public static extern void *VirtualAlloc(void *lpAddress, SizeT dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public SafeVirtualMemoryHandle Allocate(Int64 size, AllocationType allocation, MemoryProtection protection)
{
return(new SafeVirtualMemoryHandle(handle, 0, size, allocation, protection));
}
static extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize, AllocationType lAllocationType, MemoryProtection flProtect);
public static bool Reprotect(IntPtr address, IntPtr size, Memory.MemoryProtection protection)
{
MemoryProtection prot = GetProtection(protection);
return(VirtualProtect(address, size, prot, out _));
}
public static extern bool VirtualProtect(IntPtr address, uint size, MemoryProtection newProtect, out MemoryProtection oldProtect);
public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
IntPtr dwSize, MemoryProtection flNewProtect, ref MemoryProtection lpflOldProtect);
internal static extern IntPtr VirtualAllocEx(SafeProcessHandle hProcess, uint dwAddress, int nSize, AllocationType dwAllocationType, MemoryProtection dwProtect);
public static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize,
MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
public static IntPtr VirtualAlloc(UIntPtr sizeInBytes, MemoryAllocationType allocationType,
MemoryProtection protection)
{
return VirtualAlloc(IntPtr.Zero, sizeInBytes, allocationType, protection);
}
public static extern bool VirtualProtectEx([In] Handle hProcess, [In] IntPtr lpAddress, [In] int dwSize,
[In] MemoryProtection flNewProtect, [Out] out MemoryProtection lpflOldProtect);
public static extern int VirtualProtectEx(
IntPtr hProcess, UInt32 lpAddress,
uint dwSize, MemoryProtection flNewProtect,
out MemoryProtection flOldProtect
);
public static extern bool VirtualProtect(byte *lpAddress, UIntPtr dwSize,
MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
public static extern IntPtr VirtualAlloc(IntPtr address, Int32 size, AllocationType allocationType, MemoryProtection protection);
public static extern byte *VirtualAlloc(byte *lpAddress, UIntPtr dwSize,
AllocationType flAllocationType, MemoryProtection flProtect);
public MemoryFileSystem(string fileName, MfsOpenMode mode, bool readOnly, MfsParameters createParams)
{
FileCreationDispositionWin32 cdWin32;
if (readOnly && mode != MfsOpenMode.Open)
throw new ArgumentException("Invalid mode for read only access.");
switch (mode)
{
case MfsOpenMode.Open:
cdWin32 = FileCreationDispositionWin32.OpenExisting;
break;
default:
case MfsOpenMode.OpenIf:
cdWin32 = FileCreationDispositionWin32.OpenAlways;
break;
case MfsOpenMode.OverwriteIf:
cdWin32 = FileCreationDispositionWin32.CreateAlways;
break;
}
using (FileHandle fhandle = FileHandle.CreateWin32(
fileName,
FileAccess.GenericRead | (!readOnly ? FileAccess.GenericWrite : 0),
FileShareMode.Read,
cdWin32
))
{
bool justCreated = false;
_readOnly = readOnly;
_protection = !readOnly ? MemoryProtection.ReadWrite : MemoryProtection.ReadOnly;
if (fhandle.FileSize == 0)
{
if (readOnly)
{
throw new MfsInvalidFileSystemException();
}
// File is too small. Make it 1 byte large and we'll deal with it soon.
fhandle.SetEnd(1);
}
_section = new Section(fhandle, _protection);
_blockSize = MfsBlockSizeBase; // fake block size to begin with; we'll fix it up later.
if (fhandle.FileSize < _blockSize)
{
if (readOnly)
{
throw new MfsInvalidFileSystemException();
}
// We're creating a new file system. We need the correct block size now.
if (createParams != null)
this._blockSize = createParams.BlockSize;
else
this._blockSize = MfsDefaultBlockSize;
this._section.Extend(this._blockSize);
using (SectionView view = this._section.MapView(0, this._blockSize, this._protection))
{
this.InitializeFs((MfsFsHeader*)view.Memory, createParams);
}
justCreated = true;
}
_header = (MfsFsHeader*)this.ReferenceBlock(0);
// Check the magic.
if (_header->Magic != MfsMagic)
throw new MfsInvalidFileSystemException();
// Set up the local constants.
_blockSize = _header->BlockSize;
_cellSize = _header->CellSize;
// Backwards compatibility.
if (_blockSize == 0)
_blockSize = MfsDefaultBlockSize;
if (_cellSize == 0)
_cellSize = MfsDefaultCellSize;
// Validate the parameters.
this.ValidateFsParameters(_blockSize, _cellSize);
_blockMask = _blockSize - 1;
_cellCount = _blockSize / _cellSize;
_dataCellDataMaxLength = _cellSize - MfsDataCell.DataOffset;
// Remap block 0 with the correct block size.
this.DereferenceBlock(0);
// If we just created a new file system, fix the section size.
if (justCreated)
_section.Extend(_blockSize);
_header = (MfsFsHeader*)this.ReferenceBlock(0);
// Set up the root object.
_rootObjectMo = new MemoryObject(this, _rootObjectCellId, true);
if (_header->NextFreeBlock != 1 && !readOnly)
{
ushort lastBlockId = (ushort)(_header->NextFreeBlock - 1);
this.ReferenceBlock(lastBlockId);
_cachedLastBlockView = _views[lastBlockId];
}
}
}
public static extern int VirtualAllocEx(IntPtr hProcess, Int32 lpAddress,
Int32 dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize,
MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
internal static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr address, int size, AllocationType allocationType, MemoryProtection protect);
public PhysicalPagesMapping Map(IntPtr address, MemoryProtection protection)
{
// Reserve an address range.
IntPtr allocAddress = ProcessHandle.Current.AllocateMemory(
address,
_count * Windows.PageSize,
MemoryFlags.Reserve | MemoryFlags.Physical,
protection
);
// Map the physical memory into the address range.
if (!Win32.MapUserPhysicalPages(
allocAddress,
new IntPtr(_count),
_pfnArray
))
Win32.Throw();
return new PhysicalPagesMapping(this, allocAddress);
}
private static extern int VirtualProtect(IntPtr lpAddress, IntPtr dwSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
public static extern IntPtr CreateFileMapping(
IntPtr hFile, // Handle to file
SECURITY_ATTRIBUTES lpAttributes, // Security
MemoryProtection flProtect, // protection
uint dwMaximumSizeHigh, // High-order DWORD of size
uint dwMaximumSizeLow, // Low-order DWORD of size
string lpName // Object name
);
internal static extern bool VirtualProtect(IntPtr baseAddress, int protectionSize, MemoryProtection protectionType, out MemoryProtection oldProtectionType);
private string GetProtectStr(MemoryProtection protect)
{
string protectStr;
if (protect == MemoryProtection.AccessDenied)
protectStr = "";
else if ((protect & MemoryProtection.Execute) != 0)
protectStr = "X";
else if ((protect & MemoryProtection.ExecuteRead) != 0)
protectStr = "RX";
else if ((protect & MemoryProtection.ExecuteReadWrite) != 0)
protectStr = "RWX";
else if ((protect & MemoryProtection.ExecuteWriteCopy) != 0)
protectStr = "WCX";
else if ((protect & MemoryProtection.NoAccess) != 0)
protectStr = "NA";
else if ((protect & MemoryProtection.ReadOnly) != 0)
protectStr = "R";
else if ((protect & MemoryProtection.ReadWrite) != 0)
protectStr = "RW";
else if ((protect & MemoryProtection.WriteCopy) != 0)
protectStr = "WC";
else
protectStr = "?";
if ((protect & MemoryProtection.Guard) != 0)
protectStr += "+G";
if ((protect & MemoryProtection.NoCache) != 0)
protectStr += "+NC";
if ((protect & MemoryProtection.WriteCombine) != 0)
protectStr = "+WCM";
return protectStr;
}
public static extern IntPtr VirtualAllocEx(SafeProcessHandle processHandle, IntPtr address, UIntPtr size, AllocationType allocationType, MemoryProtection memoryProtection);
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public static extern IntPtr VirtualAlloc(IntPtr address, Int32 size, AllocationType allocationType, MemoryProtection protection);
internal static extern IntPtr VirtualAlloc(IntPtr startAddress, UIntPtr size, AllocationType allocationType, MemoryProtection protect);
public MemoryMappedFileStream(string name, MemoryProtection protection)
: this(name,0,protection)
{
}
