SecureString Klass

Definition

public ref class SecureString sealed : IDisposable

public sealed class SecureString : IDisposable

type SecureString = class
    interface IDisposable

Public NotInheritable Class SecureString
Implements IDisposable

Arv

Object

SecureString

Implementeringar

IDisposable

Exempel

I följande exempel visas hur du använder en SecureString för att skydda en användares lösenord för användning som autentiseringsuppgifter för att starta en ny process.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;

public class Example
{
    public static void Main()
    {
        // Instantiate the secure string.
        SecureString securePwd = new SecureString();
        ConsoleKeyInfo key;

        Console.Write("Enter password: ");
        do {
           key = Console.ReadKey(true);
           
           // Ignore any key out of range.
           if (((int) key.Key) >= 65 && ((int) key.Key <= 90)) {
              // Append the character to the password.
              securePwd.AppendChar(key.KeyChar);
              Console.Write("*");
           }   
        // Exit if Enter key is pressed.
        } while (key.Key != ConsoleKey.Enter);
        Console.WriteLine();
        
        try {
            Process.Start("Notepad.exe", "MyUser", securePwd, "MYDOMAIN");
        }
        catch (Win32Exception e) {
            Console.WriteLine(e.Message);
        }
        finally {
           securePwd.Dispose();
        }
    }
}

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security

Public Class Example
    Public Shared Sub Main()
        ' Instantiate the secure string.
        Dim securePwd As New SecureString()
        Dim key As ConsoleKeyInfo
        
        Console.Write("Enter password: ")
        Do
           key = Console.ReadKey(True)

           ' Ignore any key out of range
           If CInt(key.Key) >= 65 And CInt(key.Key <= 90) Then    
              ' Append the character to the password.
              securePwd.AppendChar(key.KeyChar)
              Console.Write("*")
           End If                                    
        ' Exit if Enter key is pressed.
        Loop While key.Key <> ConsoleKey.Enter
        Console.WriteLine()
        
        Try
            Process.Start("Notepad.exe", "MyUser", securePwd, "MYDOMAIN")
        Catch e As Win32Exception
            Console.WriteLine(e.Message)
        Finally
           securePwd.Dispose()
        End Try
    End Sub
End Class

Kommentarer

SecureString är en strängtyp som ger ett mått på säkerhet. Den försöker undvika att lagra potentiellt känsliga strängar i processminnet som oformaterad text. (För begränsningar, se dock avsnittet Hur säker är SecureString? .) Värdet för en instans av SecureString skyddas automatiskt med hjälp av en mekanism som stöds av den underliggande plattformen när instansen initieras eller när värdet ändras. Ditt program kan göra instansen oföränderlig och förhindra ytterligare ändringar genom att MakeReadOnly anropa metoden.

Den maximala längden på en SecureString instans är 65 536 tecken.

Klassen SecureString och dess medlemmar är inte synliga för COM. Mer information finns i ComVisibleAttribute.

Sträng kontra SecureString

En instans av System.String klassen är både oföränderlig och kan inte schemaläggas programmatiskt för skräpinsamling när den inte längre behövs. Instansen är skrivskyddad när den har skapats och det går inte att förutsäga när instansen tas bort från datorminnet. Eftersom System.String instanser är oföränderliga skapar åtgärder som verkar ändra en befintlig instans faktiskt en kopia av den för att manipulera. Om ett String objekt innehåller känslig information, till exempel ett lösenord, kreditkortsnummer eller personliga data, finns det därför en risk att informationen kan avslöjas efter att den har använts eftersom ditt program inte kan ta bort data från datorminnet.

Ett SecureString objekt liknar ett String objekt eftersom det har ett textvärde. Värdet för ett SecureString objekt:

• Är fäst i minnet.
• Kan använda en skyddsmekanism, till exempel kryptering, som tillhandahålls av det underliggande operativsystemet.
• Kan ändras tills programmet markerar det som skrivskyddat.
• Kan tas bort från datorminnet antingen genom att programmet anropar Dispose metoden eller av .NET skräpinsamlare.

En diskussion om begränsningarna för klassen finns i SecureString avsnittet Hur säker är SecureString?

SecureString-åtgärder

Klassen SecureString innehåller medlemmar som gör att du kan göra följande:

Instansiera ett SecureString objekt Du instansierar ett SecureString objekt genom att anropa dess parameterlösa konstruktor.

Lägg till tecken i ett SecureString objekt Du kan lägga till ett enskilt tecken i taget till ett SecureString objekt genom att anropa dess AppendChar eller InsertAt metod.

Ta bort tecken från ett SecureString objekt Du kan ersätta ett enskilt tecken genom att anropa SetAt metoden, ta bort ett enskilt tecken genom att anropa RemoveAt metoden eller ta bort alla tecken från instansen SecureString genom att anropa Clear metoden.

Gör objektet SecureString skrivskyddat När du har definierat strängen SecureString som objektet representerar anropar du dess MakeReadOnly metod för att göra strängen skrivskyddad.

Hämta information om SecureString objektet Klassen SecureString har bara två medlemmar som ger information om strängen: dess Length egenskap, vilket anger antalet UTF16-kodade kodenheter i strängen och IsReadOnlymetoden , som anger om instansen är skrivskyddad.

Frigör det minne som allokerats till instansen SecureStringSecureString Eftersom IDisposable implementerar gränssnittet släpper du dess minne genom att anropa Dispose metoden.

Klassen SecureString har inga medlemmar som inspekterar, jämför eller konverterar värdet för en SecureString. Frånvaron av sådana medlemmar hjälper till att skydda instansens värde från oavsiktlig eller skadlig exponering. Använd lämpliga medlemmar i System.Runtime.InteropServices.Marshal klassen, till exempel SecureStringToBSTR metoden, för att ändra värdet för ett SecureString objekt.

.NET-klassbiblioteket använder SecureString ofta instanser på följande sätt:

• Om du vill ange lösenordsinformation för en process med hjälp av strukturen ProcessStartInfo eller genom att anropa en överbelastad version av metoden Process.Start som har en parameter av typen SecureString.
• Ange information om nätverkslösenord genom att anropa en NetworkCredential-klasskonstruktor som har en parameter av typen SecureString eller genom att använda NetworkCredential.SecurePassword-egenskapen.
• Ange lösenordsinformation för SQL Server-autentisering genom att anropa SqlCredential.SqlCredential konstruktorn eller hämta värdet för SqlCredential.Password egenskapen.
• Skicka en sträng till ohanterad kod. Mer information finns i avsnittet SecureString och interop .

SecureString och interop

Eftersom operativsystemet inte har direkt stöd SecureStringför måste du konvertera objektets SecureString värde till den strängtyp som krävs innan du skickar strängen till en intern metod. Klassen Marshal har fem metoder som gör detta:

• Marshal.SecureStringToBSTR, som konverterar SecureString strängvärdet till en binär sträng (BSTR) som identifieras av COM.
• Marshal.SecureStringToCoTaskMemAnsi och Marshal.SecureStringToGlobalAllocAnsi, som kopierar SecureString strängvärdet till en ANSI-sträng i ohanterat minne.
• Marshal.SecureStringToCoTaskMemUnicode och Marshal.SecureStringToGlobalAllocUnicode, som kopierar SecureString strängvärdet till en Unicode-sträng i ohanterat minne.

Var och en av dessa metoder skapar en klartextsträng i ohanterat minne. Det är utvecklarens ansvar att nollställa och frigöra det minnet så snart det inte längre behövs. Var och en av strängkonverterings- och minnesallokeringsmetoderna har en motsvarande metod för att nollställa och frigöra allokerat minne:

Hur säker är SecureString?

När den har skapats korrekt ger en SecureString instans mer dataskydd än en String. När du skapar en sträng från en tecken-för-tecken-källa skapar String flera mellanliggande instanser i minnet, medan SecureString skapar bara en enda instans. Skräpinsamling av String objekt är icke-deterministisk. Dessutom, eftersom dess minne inte är bundet, gör skräpinsamlaren ytterligare kopior av String-värden när minnet flyttas och komprimeras. Däremot fästs minnet som allokeras till ett SecureString objekt och det minnet kan frigöras genom att anropa Dispose metoden.

Även om data som lagras i en SecureString instans är säkrare än data som lagras i en String instans finns det betydande begränsningar för hur säker en SecureString instans är. Dessa inkluderar:

• Plattform

  I Windows-operativsystemet krypteras innehållet i en SecureString instans interna teckenmatris. Men oavsett om det beror på saknade API:er eller problem med nyckelhantering är kryptering inte tillgängligt på alla plattformar. På grund av detta plattformsberoende SecureString krypterar inte den interna lagringen på icke-Windows-plattformen. Andra tekniker används på dessa plattformar för att ge ytterligare skydd.

• Varaktighet

  Även om implementeringen SecureString kan dra nytta av kryptering kan den oformaterade text som tilldelats instansen SecureString exponeras vid olika tidpunkter:

  • Eftersom Windows inte erbjuder en säker strängimplementering på operativsystemnivå måste .NET fortfarande konvertera värdet för säker sträng till dess oformaterade textrepresentation för att kunna använda det.
  • När värdet för den säkra strängen ändras med metoder som AppendChar eller RemoveAtmåste den dekrypteras (dvs. konverteras tillbaka till oformaterad text), ändras och sedan krypteras igen.
  • Om den säkra strängen används i ett interop-anrop måste den konverteras till en ANSI-sträng, en Unicode-sträng eller en binär sträng (BSTR). Mer information finns i avsnittet SecureString och interop .

  Tidsintervallet för vilket instansens SecureString värde exponeras förkortas bara i jämförelse med String klassen.

• Lagring jämfört med användning

  Mer allmänt SecureString definierar klassen en lagringsmekanism för strängvärden som ska skyddas eller hållas konfidentiella. Men utanför själva .NET har ingen användningsmekanism stöd för SecureString. Det innebär att den säkra strängen måste konverteras till ett användbart formulär (vanligtvis ett tydligt textformulär) som kan identifieras av målet och att dekryptering och konvertering måste ske i användarutrymme.

SecureString Generellt sett är det säkrare än String eftersom det begränsar exponeringen av känsliga strängdata. Dessa strängar kan dock fortfarande exponeras för alla processer eller åtgärder som har åtkomst till rådataminne, till exempel en skadlig process som körs på värddatorn, en processdump eller en användarvisningsbar växlingsfil. I stället för att använda SecureString för att skydda lösenord är det rekommenderade alternativet att använda en ogenomskinlig referens till autentiseringsuppgifter som lagras utanför processen.

Se även

• ComVisibleAttribute
• Marshal
• CriticalFinalizerObject
• IDisposable