C#SecureString pregunta

.net

Question

¿Hay alguna manera de obtener el valor de un SecureString sin incluir la seguridad? Por ejemplo, en el código a continuación, tan pronto como lo hace PtrToStringBSTR, la cadena ya no es segura porque las cadenas son inmutables y la recolección de basura no es determinista para las cadenas.

IntPtr ptr = Marshal.SecureStringToBSTR(SecureString object);
string value = Marshal.PtrToStringBSTR(ptr);

¿Qué pasaría si hubiera una forma de obtener un char [] o un byte [] de la cadena BSTR no administrada? ¿Eso significa que la recolección de basura es más predecible (ya que utilizaría un char [] o un byte [] en lugar de una cadena? ¿Es correcto este supuesto, y si es así, cómo recuperaría el char [] o el byte []?

Answer 1

Aquí hay una clase que he escrito especialmente para este propósito. ¿Es completamente, 100% a prueba de hackers? No, es muy poco lo que puede hacer para que una aplicación sea 100% segura, pero esta clase va tan lejos como puede para protegerse si necesita convertir un SecureString en un String .

Así es como usas la clase:

using(SecureStringToStringMarshaler sm = new SecureStringToStringMarshaler(secureString))
{
// Use sm.String here. While in the ''using'' block, the string is accessible
// but pinned in memory. When the ''using'' block terminates, the string is zeroed
// out for security, and garbage collected as usual.
}

Aqui esta la clase

/// Copyright (C) 2010 Douglas Day
/// All rights reserved.
/// MIT-licensed: http://www.opensource.org/licenses/mit-license.php
using System;
using System.Collections.Generic;
using System.Text;
using System.Security;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
namespace DDay.Base
{
public class SecureStringToStringMarshaler : IDisposable
{
#region Private Fields
private string _String;
private SecureString _SecureString;
private GCHandle _GCH;
#endregion
#region Public Properties
public SecureString SecureString
{
get { return _SecureString; }
set
{
_SecureString = value;
UpdateStringValue();
}
}
public string String
{
get { return _String; }
protected set { _String = value; }
}
#endregion
#region Constructors
public SecureStringToStringMarshaler()
{
}
public SecureStringToStringMarshaler(SecureString ss)
{
SecureString = ss;
}
#endregion
#region Private Methods
void UpdateStringValue()
{
Deallocate();
unsafe
{
if (SecureString != null)
{
int length = SecureString.Length;
String = new string(''/0'', length);
_GCH = new GCHandle();
// Create a CER (Contrained Execution Region)
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
// Pin our string, disallowing the garbage collector from
// moving it around.
_GCH = GCHandle.Alloc(String, GCHandleType.Pinned);
}
IntPtr stringPtr = IntPtr.Zero;
RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(
delegate
{
// Create a CER (Contrained Execution Region)
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
stringPtr = Marshal.SecureStringToBSTR(SecureString);
}
// Copy the SecureString content to our pinned string
char* pString = (char*)stringPtr;
char* pInsecureString = (char*)_GCH.AddrOfPinnedObject();
for (int index = 0; index < length; index++)
{
pInsecureString[index] = pString[index];
}
},
delegate
{
if (stringPtr != IntPtr.Zero)
{
// Free the SecureString BSTR that was generated
Marshal.ZeroFreeBSTR(stringPtr);
}
},
null);
}
}
}
void Deallocate()
{
if (_GCH.IsAllocated)
{
unsafe
{
// Determine the length of the string
int length = String.Length;
// Zero each character of the string.
char* pInsecureString = (char*)_GCH.AddrOfPinnedObject();
for (int index = 0; index < length; index++)
{
pInsecureString[index] = ''/0'';
}
// Free the handle so the garbage collector
// can dispose of it properly.
_GCH.Free();
}
}
}
#endregion
#region IDisposable Members
public void Dispose()
{
Deallocate();
}
#endregion
}
}

Este código requiere que pueda compilar código unsafe , pero funciona como un encanto.

Saludos,

-Doug

Answer 2

El enlace que Mark proporcionó es sobre lo mejor que puede hacer, y es el enfoque que mi equipo ha adoptado para abordar este problema (aunque no fuimos a la complejidad de usar los CER). Tenía algunas dudas sobre el uso de la fijación para romper esencialmente la inmutabilidad de la cadena C #, pero funciona.

Answer 3

Esto debería ayudarlo a usted: Acercar las contraseñas SecureString a la cadena

Del artículo, los puntos clave son:

• Pin la cadena en la memoria.
• Utilice punteros gestionados para mutar el System.String.
• Utilice las garantías sólidas del método ExecuteCodeWithGuaranteedCleanup.

Answer 4

Los SecureStrings solo son seguros mientras no los uses. ) -;

Lo 1 que no debes hacer es copiar en una cadena (independientemente del método). La cadena es inmutable y potencialmente puede permanecer en la memoria durante mucho tiempo.

Copiarlo a un char [] es un poco más seguro siempre y cuando se tome la precaución de poner a cero esa matriz lo antes posible. Pero la matriz está presente en la memoria por algún tiempo y eso es un riesgo de seguridad (incumplimiento).

Desafortunadamente, hay muy poco soporte para SecureStrings en la biblioteca. La forma más común de trabajar con ellos es una char a la vez.

Editar:

la matriz char[] debe estar anclada, y Mark Byers proporciona un enlace a un artículo que hace lo mismo con una cadena anclada. Es una cuestión de elección, pero el riesgo de la cadena es que es muy fácil copiarla (pasarla a algún método que realice un Trim() sería suficiente).

Answer 5

Utilice Marshal.ZeroFreeBSTR :

EDITAR: Sí, crear una nueva Cadena creará una copia, por lo que perderá el control sobre la limpieza de los contenidos. Puede acceder al char [] lanzando el puntero devuelto por IntPtr.ToPointer () en un contexto inseguro:

IntPtr ptr = Marshal.SecureStringToBSTR(str);
unsafe
{
char *cp = (char*)ptr.ToPointer();
//access char[] through cp
}
Marshal.ZeroFreeBSTR(ptr);