internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target, uint bytesToCopy)
{
if (bytesToCopy == 0)
{
return;
}
byte *sourcePtr = null, targetPtr = null;
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Debug.Assert(Interop.OleAut32.SysStringLen((IntPtr)sourcePtr) * sizeof(char) >= bytesToCopy, "Source buffer is too small.");
Buffer.MemoryCopy(sourcePtr, targetPtr, Interop.OleAut32.SysStringLen((IntPtr)targetPtr) * sizeof(char), bytesToCopy);
}
finally
{
if (sourcePtr != null)
{
source.ReleasePointer();
}
if (targetPtr != null)
{
target.ReleasePointer();
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
private unsafe void RemoveAtCore(int index)
{
byte * bufferPtr = null;
SafeBSTRHandle decryptedBuffer = null;
try
{
decryptedBuffer = UnProtectMemory();
decryptedBuffer.AcquirePointer(ref bufferPtr);
char *pBuffer = (char *)bufferPtr;
for (int i = index; i < _decryptedLength - 1; i++)
{
pBuffer[i] = pBuffer[i + 1];
}
pBuffer[--_decryptedLength] = (char)0;
}
finally
{
ProtectMemory(decryptedBuffer);
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
}
internal static unsafe void Copy(SafeBSTRHandle source, SafeBSTRHandle target, uint bytesToCopy)
{
if (bytesToCopy == 0)
{
return;
}
byte *sourcePtr = null, targetPtr = null;
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Debug.Assert(source.ByteLength >= bytesToCopy, "Source buffer is too small.");
Buffer.MemoryCopy(sourcePtr, targetPtr, target.ByteLength, bytesToCopy);
}
finally
{
if (targetPtr != null)
{
target.ReleasePointer();
}
if (sourcePtr != null)
{
source.ReleasePointer();
}
}
}
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte *sourcePtr = null, targetPtr = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Contract.Assert(Win32Native.SysStringLen((IntPtr)targetPtr) >= Win32Native.SysStringLen((IntPtr)sourcePtr), "Target buffer is not large enough!");
Buffer.Memcpy(targetPtr, sourcePtr, (int)Win32Native.SysStringLen((IntPtr)sourcePtr) * 2);
}
finally
{
if (sourcePtr != null)
{
source.ReleasePointer();
}
if (targetPtr != null)
{
target.ReleasePointer();
}
}
}
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target, uint bytesToCopy)
{
if (bytesToCopy == 0)
{
return;
}
byte* sourcePtr = null, targetPtr = null;
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Debug.Assert(source.ByteLength >= bytesToCopy, "Source buffer is too small.");
Buffer.MemoryCopy(sourcePtr, targetPtr, target.ByteLength, bytesToCopy);
}
finally
{
if (targetPtr != null)
{
target.ReleasePointer();
}
if (sourcePtr != null)
{
source.ReleasePointer();
}
}
}
[System.Security.SecurityCritical] // auto-generated
private unsafe void InitializeSecureString(char *value, int length)
{
if (length == 0)
{
AllocateBuffer(0);
_decryptedLength = 0;
return;
}
_encryptedBuffer = SafeBSTRHandle.Allocate(null, 0);
SafeBSTRHandle decryptedBuffer = SafeBSTRHandle.Allocate(null, (uint)length);
_decryptedLength = length;
byte *bufferPtr = null;
try
{
decryptedBuffer.AcquirePointer(ref bufferPtr);
Buffer.MemoryCopy((byte *)value, bufferPtr, decryptedBuffer.Length * sizeof(char), length * sizeof(char));
}
finally
{
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
ProtectMemory(decryptedBuffer);
}
internal static unsafe bool CryptProtectData(SafeBSTRHandle uncryptedBuffer, out SafeBSTRHandle cryptedBuffer)
{
byte* uncryptedBufferPtr = null;
DATA_BLOB pDataOut = default(DATA_BLOB);
try
{
uncryptedBuffer.AcquirePointer(ref uncryptedBufferPtr);
DATA_BLOB pDataIn = new DATA_BLOB((IntPtr)uncryptedBufferPtr, uncryptedBuffer.Length * 2);
if (CryptProtectData(new IntPtr(&pDataIn), String.Empty, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, CRYPTPROTECTMEMORY_SAME_PROCESS, new IntPtr(&pDataOut)))
{
SafeBSTRHandle newHandle = SafeBSTRHandle.Allocate(pDataOut.pbData, pDataOut.cbData);
cryptedBuffer = newHandle;
return true;
}
else
{
cryptedBuffer = SafeBSTRHandle.Allocate(null, 0);
return false;
}
}
finally
{
if (uncryptedBufferPtr != null)
uncryptedBuffer.ReleasePointer();
if (pDataOut.pbData != IntPtr.Zero)
{
NtDll.ZeroMemory(pDataOut.pbData, (UIntPtr)pDataOut.cbData);
Marshal.FreeHGlobal(pDataOut.pbData);
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
private unsafe void InsertAtCore(int index, char c)
{
byte * bufferPtr = null;
SafeBSTRHandle decryptedBuffer = null;
try
{
decryptedBuffer = UnProtectMemory();
EnsureCapacity(ref decryptedBuffer, _decryptedLength + 1);
decryptedBuffer.AcquirePointer(ref bufferPtr);
char *pBuffer = (char *)bufferPtr;
for (int i = _decryptedLength; i > index; i--)
{
pBuffer[i] = pBuffer[i - 1];
}
pBuffer[index] = c;
++_decryptedLength;
}
finally
{
ProtectMemory(decryptedBuffer);
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
}
private unsafe void InitializeSecureString(char *value, int length)
{
CheckSupportedOnCurrentPlatform();
AllocateBuffer(length);
m_length = length;
byte *bufferPtr = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
m_buffer.AcquirePointer(ref bufferPtr);
Buffer.Memcpy(bufferPtr, (byte *)value, length * 2);
}
catch (Exception) {
ProtectMemory();
throw;
}
finally
{
if (bufferPtr != null)
{
m_buffer.ReleasePointer();
}
}
ProtectMemory();
}
[System.Security.SecurityCritical] // auto-generated
internal unsafe IntPtr ToUniStr()
{
lock (_methodLock)
{
EnsureNotDisposed();
int length = _decryptedLength;
IntPtr ptr = IntPtr.Zero;
IntPtr result = IntPtr.Zero;
byte * bufferPtr = null;
SafeBSTRHandle decryptedBuffer = null;
try
{
ptr = Marshal.AllocCoTaskMem((length + 1) * 2);
if (ptr == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
decryptedBuffer = UnProtectMemory();
decryptedBuffer.AcquirePointer(ref bufferPtr);
Buffer.MemoryCopy(bufferPtr, (byte *)ptr.ToPointer(), ((length + 1) * 2), length * 2);
char *endptr = (char *)ptr.ToPointer();
*(endptr + length) = '\0';
result = ptr;
}
finally
{
if (result == IntPtr.Zero)
{
// If we failed for any reason, free the new buffer
if (ptr != IntPtr.Zero)
{
Interop.NtDll.ZeroMemory(ptr, (UIntPtr)(length * 2));
Marshal.FreeCoTaskMem(ptr);
}
}
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
return(result);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public void InsertAt(int index, char c)
{
lock (_methodLock)
{
if (index < 0 || index > _decryptedLength)
{
throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexString);
}
EnsureNotDisposed();
EnsureNotReadOnly();
unsafe
{
byte * bufferPtr = null;
SafeBSTRHandle decryptedBuffer = null;
try
{
decryptedBuffer = UnProtectMemory();
EnsureCapacity(ref decryptedBuffer, _decryptedLength + 1);
decryptedBuffer.AcquirePointer(ref bufferPtr);
char *pBuffer = (char *)bufferPtr;
for (int i = _decryptedLength; i > index; i--)
{
pBuffer[i] = pBuffer[i - 1];
}
pBuffer[index] = c;
++_decryptedLength;
}
finally
{
ProtectMemory(decryptedBuffer);
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public void RemoveAt(int index)
{
lock (_methodLock)
{
EnsureNotDisposed();
EnsureNotReadOnly();
if (index < 0 || index >= _decryptedLength)
{
throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexString);
}
unsafe
{
byte * bufferPtr = null;
SafeBSTRHandle decryptedBuffer = null;
try
{
decryptedBuffer = UnProtectMemory();
decryptedBuffer.AcquirePointer(ref bufferPtr);
char *pBuffer = (char *)bufferPtr;
for (int i = index; i < _decryptedLength - 1; i++)
{
pBuffer[i] = pBuffer[i + 1];
}
pBuffer[--_decryptedLength] = (char)0;
}
finally
{
ProtectMemory(decryptedBuffer);
if (bufferPtr != null)
{
decryptedBuffer.ReleasePointer();
}
}
}
}
}
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target, uint bytesToCopy)
{
if (bytesToCopy == 0)
return;
byte* sourcePtr = null, targetPtr = null;
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Debug.Assert(Interop.OleAut32.SysStringLen((IntPtr)sourcePtr) * sizeof(char) >= bytesToCopy, "Source buffer is too small.");
Buffer.MemoryCopy(sourcePtr, targetPtr, Interop.OleAut32.SysStringLen((IntPtr)targetPtr) * sizeof(char), bytesToCopy);
}
finally
{
if (sourcePtr != null)
source.ReleasePointer();
if (targetPtr != null)
target.ReleasePointer();
}
}
internal static unsafe void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte* pointer = null;
byte* numPtr2 = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref pointer);
target.AcquirePointer(ref numPtr2);
Buffer.memcpyimpl(pointer, numPtr2, Win32Native.SysStringLen((IntPtr) pointer) * 2);
}
finally
{
if (pointer != null)
{
source.ReleasePointer();
}
if (numPtr2 != null)
{
target.ReleasePointer();
}
}
}
internal static unsafe void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte *pointer = null;
byte *numPtr2 = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref pointer);
target.AcquirePointer(ref numPtr2);
Buffer.memcpyimpl(pointer, numPtr2, Win32Native.SysStringLen((IntPtr)pointer) * 2);
}
finally
{
if (pointer != null)
{
source.ReleasePointer();
}
if (numPtr2 != null)
{
target.ReleasePointer();
}
}
}
// Token: 0x06001DAD RID: 7597 RVA: 0x000678A4 File Offset: 0x00065AA4
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte *ptr = null;
byte *ptr2 = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref ptr);
target.AcquirePointer(ref ptr2);
Buffer.Memcpy(ptr2, ptr, (int)(Win32Native.SysStringLen((IntPtr)((void *)ptr)) * 2U));
}
finally
{
if (ptr != null)
{
source.ReleasePointer();
}
if (ptr2 != null)
{
target.ReleasePointer();
}
}
}
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte *sourcePtr = null, targetPtr = null;
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Debug.Assert(Interop.OleAut32.SysStringLen((IntPtr)targetPtr) >= Interop.OleAut32.SysStringLen((IntPtr)sourcePtr), "Target buffer is not large enough!");
Buffer.MemoryCopy(sourcePtr, targetPtr, (int)Interop.OleAut32.SysStringLen((IntPtr)targetPtr) * sizeof(char), (int)Interop.OleAut32.SysStringLen((IntPtr)sourcePtr) * sizeof(char));
}
finally
{
if (sourcePtr != null)
{
source.ReleasePointer();
}
if (targetPtr != null)
{
target.ReleasePointer();
}
}
}
internal static unsafe void Copy(SafeBSTRHandle source, SafeBSTRHandle target)
{
byte *pointer1 = (byte *)null;
byte *pointer2 = (byte *)null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref pointer1);
target.AcquirePointer(ref pointer2);
Buffer.Memcpy(pointer2, pointer1, (int)Win32Native.SysStringLen((IntPtr)((void *)pointer1)) * 2);
}
finally
{
if ((IntPtr)pointer1 != IntPtr.Zero)
{
source.ReleasePointer();
}
if ((IntPtr)pointer2 != IntPtr.Zero)
{
target.ReleasePointer();
}
}
}
internal unsafe static void Copy(SafeBSTRHandle source, SafeBSTRHandle target) {
byte* sourcePtr = null, targetPtr = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
source.AcquirePointer(ref sourcePtr);
target.AcquirePointer(ref targetPtr);
Contract.Assert(Win32Native.SysStringLen((IntPtr)targetPtr) >= Win32Native.SysStringLen((IntPtr)sourcePtr), "Target buffer is not large enough!");
Buffer.Memcpy(targetPtr, sourcePtr, (int) Win32Native.SysStringLen((IntPtr)sourcePtr) * 2);
}
finally
{
if (sourcePtr != null)
source.ReleasePointer();
if (targetPtr != null)
target.ReleasePointer();
}
}
