Eu acho que seria melhor para SecureStringfunções dependentes encapsular sua lógica dependente em uma função anônima para melhor controle sobre a string descriptografada na memória (uma vez fixada).
A implementação para descriptografar SecureStrings neste trecho irá:
- Coloque a sequência na memória (que é o que você deseja fazer, mas parece estar faltando na maioria das respostas aqui).
- Passe sua referência ao delegado Func / Action.
- Limpe-o da memória e libere o GC no
finallybloco.
Obviamente, isso torna muito mais fácil "padronizar" e manter os chamadores versus confiar em alternativas menos desejáveis:
- Retornando a sequência descriptografada de uma
string DecryptSecureString(...)função auxiliar.
- Duplicar esse código sempre que necessário.
Observe aqui, você tem duas opções:
static T DecryptSecureString<T>que permite acessar o resultado do Funcdelegado do chamador (conforme mostrado naDecryptSecureStringWithFunc método de teste).static void DecryptSecureStringé simplesmente uma versão "vazia" que emprega um Actiondelegado nos casos em que você realmente não deseja / precisa retornar nada (como demonstrado no DecryptSecureStringWithActionmétodo de teste).
Exemplo de uso para ambos pode ser encontrado na StringsTestclasse incluída.
Strings.cs
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SecurityUtils
{
public partial class Strings
{
/// <summary>
/// Passes decrypted password String pinned in memory to Func delegate scrubbed on return.
/// </summary>
/// <typeparam name="T">Generic type returned by Func delegate</typeparam>
/// <param name="action">Func delegate which will receive the decrypted password pinned in memory as a String object</param>
/// <returns>Result of Func delegate</returns>
public static T DecryptSecureString<T>(SecureString secureString, Func<string, T> action)
{
var insecureStringPointer = IntPtr.Zero;
var insecureString = String.Empty;
var gcHandler = GCHandle.Alloc(insecureString, GCHandleType.Pinned);
try
{
insecureStringPointer = Marshal.SecureStringToGlobalAllocUnicode(secureString);
insecureString = Marshal.PtrToStringUni(insecureStringPointer);
return action(insecureString);
}
finally
{
//clear memory immediately - don't wait for garbage collector
fixed(char* ptr = insecureString )
{
for(int i = 0; i < insecureString.Length; i++)
{
ptr[i] = '\0';
}
}
insecureString = null;
gcHandler.Free();
Marshal.ZeroFreeGlobalAllocUnicode(insecureStringPointer);
}
}
/// <summary>
/// Runs DecryptSecureString with support for Action to leverage void return type
/// </summary>
/// <param name="secureString"></param>
/// <param name="action"></param>
public static void DecryptSecureString(SecureString secureString, Action<string> action)
{
DecryptSecureString<int>(secureString, (s) =>
{
action(s);
return 0;
});
}
}
}
StringsTest.cs
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Security;
namespace SecurityUtils.Test
{
[TestClass]
public class StringsTest
{
[TestMethod]
public void DecryptSecureStringWithFunc()
{
// Arrange
var secureString = new SecureString();
foreach (var c in "UserPassword123".ToCharArray())
secureString.AppendChar(c);
secureString.MakeReadOnly();
// Act
var result = Strings.DecryptSecureString<bool>(secureString, (password) =>
{
return password.Equals("UserPassword123");
});
// Assert
Assert.IsTrue(result);
}
[TestMethod]
public void DecryptSecureStringWithAction()
{
// Arrange
var secureString = new SecureString();
foreach (var c in "UserPassword123".ToCharArray())
secureString.AppendChar(c);
secureString.MakeReadOnly();
// Act
var result = false;
Strings.DecryptSecureString(secureString, (password) =>
{
result = password.Equals("UserPassword123");
});
// Assert
Assert.IsTrue(result);
}
}
}
Obviamente, isso não impede o abuso dessa função da seguinte maneira, portanto, tome cuidado para não fazer isso:
[TestMethod]
public void DecryptSecureStringWithAction()
{
// Arrange
var secureString = new SecureString();
foreach (var c in "UserPassword123".ToCharArray())
secureString.AppendChar(c);
secureString.MakeReadOnly();
// Act
string copyPassword = null;
Strings.DecryptSecureString(secureString, (password) =>
{
copyPassword = password; // Please don't do this!
});
// Assert
Assert.IsNull(copyPassword); // Fails
}
Feliz codificação!