Aquí podría ser tu PUBLICIDAD


Consideraciones al construir un tipo de cadena segura

votos
0

Comencé a construir un tipo de cadena segura, que llamo SecureStringV2 , para extender el tipo existente de SecureString en .Net Framework. Este nuevo tipo agregará algunas funcionalidades básicas (comprobación de igualdad, comparación, etc.) al tipo existente, pero aún mantiene la seguridad proporcionada por el tipo SecureString, es decir, todo lo que quede fuera de la memoria después del uso de los tipos. Planeo lograr estas características usando la clase Marshal y los algoritmos hash. Se apreciarán los consejos sobre cómo hacer esto bien hecho. ¿Alguno de ustedes ve algún problema con mis ideas para implementar esto? Gracias :)

Actualización: Aquí es donde mis ideas me han llevado hasta ahora con respecto a la clase principal de la biblioteca. échale un vistazo y cuéntame tus pensamientos.

/// <summary>
///  This class is extension of the SecureString Class in the .Net framework. 
///  It provides checks for equality of multiple SStringV2 instances and maintains
///  the security provided by the SecureString Class
/// </summary>
public class SStringV2 : IEquatable<SStringV2> , IDisposable
{
    private SecureString secureString = new SecureString();
    private Byte[] sStringBytes;
    private String hash = string.Empty;

    /// <summary>
    ///  SStringV2 constructor
    /// </summary>
    /// <param name=confidentialData></param>
    public SStringV2(ref Char[] confidentialData)
    {
        GCHandle charArrayHandle = GCHandle.Alloc(confidentialData, GCHandleType.Pinned);
        // The unmanaged string splices a zero byte inbetween every two bytes 
        //and at its end  doubling the total number of bytes
        sStringBytes = new Byte[confidentialData.Length*2];
        try
        {
            for (int index = 0; index < confidentialData.Length; ++index)
            {                   
                secureString.AppendChar(confidentialData[index]);
            }
        }
        finally
        {
            ZeroOutSequence.ZeroOutArray(ref confidentialData);
            charArrayHandle.Free();
        }
    }

    /// <summary>
    /// Computes the hash value of the secured string 
    /// </summary>
    private void GenerateHash()
    {
        IntPtr unmanagedRef = Marshal.SecureStringToBSTR(secureString);
        GCHandle byteArrayHandle = GCHandle.Alloc(sStringBytes, GCHandleType.Pinned);
        Marshal.Copy(unmanagedRef, sStringBytes, 0, sStringBytes.Length);
        SHA256Managed SHA256 = new SHA256Managed();

        try
        {
            hash = Convert.ToBase64String(SHA256.ComputeHash(this.sStringBytes));
        }
        finally
        {
            SHA256.Clear();
            ZeroOutSequence.ZeroOutArray(ref sStringBytes);
            byteArrayHandle.Free(); 
            Marshal.ZeroFreeBSTR(unmanagedRef);
        }
    }

    #region IEquatable<SStringV2> Members

    public bool Equals(SStringV2 other)
    {
        if ((this.hash == string.Empty) & ( other.hash == string.Empty))
        { 
            this.GenerateHash();
            other.GenerateHash();
        }
        else if ((this.hash == string.Empty) & !(other.hash == string.Empty))
        {
            this.GenerateHash();
        }
        else if (!(this.hash == string.Empty) & (other.hash == string.Empty))
        {
            other.GenerateHash();
        }

        if (this.hash.Equals(other.hash))
        {
            return true;
        }
            return false;
    }

    #endregion

    #region IDisposable Members

    public void Dispose()
    {
        secureString.Dispose();
        hash = string.Empty;
        GC.SuppressFinalize(this);
    }

    #endregion
}

}

Publicado el 12/03/2009 a las 15:30
fuente por usuario gogole
En otros idiomas...        العربية       

3 respuestas

votos
1

No hay que olvidar que SecureString utiliza el cifrado de dos vías. No veo ningún tipo de cifrado en su clase.

Respondida el 25/08/2010 a las 05:28
fuente por usuario Doug


Aquí podría ser tu PUBLICIDAD


votos
1

Solo una nota rápida - Estás preguntando por problemas al confundir la igualdad de hash con la igualdad de datos - seguro de que la probabilidad de que sean diferentes es baja, pero una vez que la alcanzas será una pesadilla: / (Tuve la "suerte" de depurar y arreglamos una implementación personalizada de hash-map que cometió el mismo error hace unos años, así que por favor confía en mí en esto;)).

Respondida el 12/03/2009 a las 07:58
fuente por usuario RnR

votos
0

si pasas una matriz char [] en, comienzas a perder los beneficios de la seguridad. El cobrador de basura puede copiar la matriz char [] en la memoria antes de borrarla.

Respondida el 12/03/2009 a las 06:30
fuente por usuario drscroogemcduck