Rfc2898DeriveBytes Osztály

Definíció

Névtér:

System.Security.Cryptography

Szerelvények:

netstandard.dll, System.Security.Cryptography.dll

Forrás:

Rfc2898DeriveBytes.cs

A PBKDF2 jelszóalapú kulcs származtatási funkcióját egy pszeudo-véletlenszerű számgenerátor használatával valósítja meg a következő alapján HMACSHA1: .

public ref class Rfc2898DeriveBytes : System::Security::Cryptography::DeriveBytes

public class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes

type Rfc2898DeriveBytes = class
    inherit DeriveBytes

Public Class Rfc2898DeriveBytes
Inherits DeriveBytes

Öröklődés

Object

DeriveBytes

Rfc2898DeriveBytes

Példák

Az alábbi példakód az Rfc2898DeriveBytes osztály használatával hoz létre két azonos kulcsot az Aes osztályhoz. Ezután titkosít és visszafejt bizonyos adatokat a kulcsok használatával.

using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;

public class rfc2898test
{
    // Generate a key k1 with password pwd1 and salt salt1.
    // Generate a key k2 with password pwd1 and salt salt1.
    // Encrypt data1 with key k1 using symmetric encryption, creating edata1.
    // Decrypt edata1 with key k2 using symmetric decryption, creating data2.
    // data2 should equal data1.

    private const string usageText = "Usage: RFC2898 <password>\nYou must specify the password for encryption.\n";
    public static void Main(string[] passwordargs)
    {
        //If no file name is specified, write usage text.
        if (passwordargs.Length == 0)
        {
            Console.WriteLine(usageText);
        }
        else
        {
            string pwd1 = passwordargs[0];
            // Create a byte array to hold the random value.
            byte[] salt1 = new byte[8];
            using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
            {
                // Fill the array with a random value.
                rng.GetBytes(salt1);
            }

            //data1 can be a string or contents of a file.
            string data1 = "Some test data";
            //The legacy default iteration count is 1000 so the two methods use the same iteration count.
            int myIterations = 1000;
            try
            {
                Rfc2898DeriveBytes k1 = new Rfc2898DeriveBytes(pwd1, salt1,
myIterations);
                Rfc2898DeriveBytes k2 = new Rfc2898DeriveBytes(pwd1, salt1);
                // Encrypt the data.
                Aes encAlg = Aes.Create();
                encAlg.Key = k1.GetBytes(16);
                MemoryStream encryptionStream = new MemoryStream();
                CryptoStream encrypt = new CryptoStream(encryptionStream,
encAlg.CreateEncryptor(), CryptoStreamMode.Write);
                byte[] utfD1 = new System.Text.UTF8Encoding(false).GetBytes(
data1);

                encrypt.Write(utfD1, 0, utfD1.Length);
                encrypt.FlushFinalBlock();
                encrypt.Close();
                byte[] edata1 = encryptionStream.ToArray();
                k1.Reset();

                // Try to decrypt, thus showing it can be round-tripped.
                Aes decAlg = Aes.Create();
                decAlg.Key = k2.GetBytes(16);
                decAlg.IV = encAlg.IV;
                MemoryStream decryptionStreamBacking = new MemoryStream();
                CryptoStream decrypt = new CryptoStream(
decryptionStreamBacking, decAlg.CreateDecryptor(), CryptoStreamMode.Write);
                decrypt.Write(edata1, 0, edata1.Length);
                decrypt.Flush();
                decrypt.Close();
                k2.Reset();
                string data2 = new UTF8Encoding(false).GetString(
decryptionStreamBacking.ToArray());

                if (!data1.Equals(data2))
                {
                    Console.WriteLine("Error: The two values are not equal.");
                }
                else
                {
                    Console.WriteLine("The two values are equal.");
                    Console.WriteLine("k1 iterations: {0}", k1.IterationCount);
                    Console.WriteLine("k2 iterations: {0}", k2.IterationCount);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e);
            }
        }
    }
}

Imports System.IO
Imports System.Text
Imports System.Security.Cryptography



Public Class rfc2898test
    ' Generate a key k1 with password pwd1 and salt salt1.
    ' Generate a key k2 with password pwd1 and salt salt1.
    ' Encrypt data1 with key k1 using symmetric encryption, creating edata1.
    ' Decrypt edata1 with key k2 using symmetric decryption, creating data2.
    ' data2 should equal data1.
    Private Const usageText As String = "Usage: RFC2898 <password>" + vbLf + "You must specify the password for encryption." + vbLf

    Public Shared Sub Main(ByVal passwordargs() As String)
        'If no file name is specified, write usage text.
        If passwordargs.Length = 0 Then
            Console.WriteLine(usageText)
        Else
            Dim pwd1 As String = passwordargs(0)

            Dim salt1(8) As Byte
            Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
                rng.GetBytes(salt1)
            End Using
            'data1 can be a string or contents of a file.
            Dim data1 As String = "Some test data"
            'The legacy default iteration count is 1000 so the two methods use the same iteration count.
            Dim myIterations As Integer = 1000
            Try
                Dim k1 As New Rfc2898DeriveBytes(pwd1, salt1, myIterations)
                Dim k2 As New Rfc2898DeriveBytes(pwd1, salt1)
                ' Encrypt the data.
                Dim encAlg As Aes = Aes.Create()
                encAlg.Key = k1.GetBytes(16)
                Dim encryptionStream As New MemoryStream()
                Dim encrypt As New CryptoStream(encryptionStream, encAlg.CreateEncryptor(), CryptoStreamMode.Write)
                Dim utfD1 As Byte() = New System.Text.UTF8Encoding(False).GetBytes(data1)
                encrypt.Write(utfD1, 0, utfD1.Length)
                encrypt.FlushFinalBlock()
                encrypt.Close()
                Dim edata1 As Byte() = encryptionStream.ToArray()
                k1.Reset()

                ' Try to decrypt, thus showing it can be round-tripped.
                Dim decAlg As Aes = Aes.Create()
                decAlg.Key = k2.GetBytes(16)
                decAlg.IV = encAlg.IV
                Dim decryptionStreamBacking As New MemoryStream()
                Dim decrypt As New CryptoStream(decryptionStreamBacking, decAlg.CreateDecryptor(), CryptoStreamMode.Write)
                decrypt.Write(edata1, 0, edata1.Length)
                decrypt.Flush()
                decrypt.Close()
                k2.Reset()
                Dim data2 As String = New UTF8Encoding(False).GetString(decryptionStreamBacking.ToArray())

                If Not data1.Equals(data2) Then
                    Console.WriteLine("Error: The two values are not equal.")
                Else
                    Console.WriteLine("The two values are equal.")
                    Console.WriteLine("k1 iterations: {0}", k1.IterationCount)
                    Console.WriteLine("k2 iterations: {0}", k2.IterationCount)
                End If
            Catch e As Exception
                Console.WriteLine("Error: ", e)
            End Try
        End If

    End Sub
End Class

Megjegyzések

Rfc2898DeriveBytes jelszót, sót és iterációs számot használ, majd kulcsokat hoz létre a GetBytes metódushoz intézett hívásokon keresztül.

Az RFC 2898 egy kulcs- és inicializálási vektor (IV) jelszóból és sóból történő létrehozására szolgáló módszereket tartalmaz. A PBKDF2 jelszóalapú kulcslevezetési függvény használatával olyan pszeudo-véletlenszerű függvény használatával származtathatja a kulcsokat, amelyek gyakorlatilag korlátlan hosszúságú kulcsokat hoznak létre. Az Rfc2898DeriveBytes osztály használható származtatott kulcs létrehozásához egy alapkulcsból és más paraméterekből. A jelszóalapú kulcs származtatási függvényben az alapkulcs egy jelszó, a többi paraméter pedig egy sóérték és egy iterációs szám.

További információ a PBKDF2-ről: "PKCS #5: Password-Based Titkosítási specifikáció 2.0-s verziója" című RFC 2898-at. A részletekért tekintse meg az 5.2.,"PBKDF2" szakaszt.

Important

Soha ne kódjon jelszót a forráskódon belül. A kemény kóddal kódolt jelszavak a Ildasm.exe (IL Disassembler) használatával, hexadecimális szerkesztő használatával, vagy egyszerűen a szerelvény megnyitásával kérhetők le egy szövegszerkesztőben, például Notepad.exe.

Konstruktorok

Name	Description
Rfc2898DeriveBytes(Byte[], Byte[], Int32, HashAlgorithmName)	Elavult. Inicializálja az osztály új példányát a Rfc2898DeriveBytes megadott jelszóval, sóval, iterációk számával és a kivonatoló algoritmus nevével a kulcs levezetéséhez.
Rfc2898DeriveBytes(Byte[], Byte[], Int32)	Elavult. Inicializálja az Rfc2898DeriveBytes osztály új példányát jelszó, só és iterációk számával a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Byte[], Int32, HashAlgorithmName)	Elavult. Inicializálja az osztály új példányát a Rfc2898DeriveBytes megadott jelszóval, sóval, iterációk számával és a kivonatoló algoritmus nevével a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Byte[], Int32)	Elavult. Inicializálja az Rfc2898DeriveBytes osztály új példányát jelszó, só és iterációk számával a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Byte[])	Elavult. Inicializálja az Rfc2898DeriveBytes osztály új példányát jelszó és só használatával a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Int32, Int32, HashAlgorithmName)	Elavult. Inicializálja az osztály új példányát a Rfc2898DeriveBytes megadott jelszó, sóméret, iterációk száma és a kivonatoló algoritmus nevének használatával a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Int32, Int32)	Elavult. Az osztály új példányát Rfc2898DeriveBytes inicializálja jelszó, sóméret és iterációk számával a kulcs levezetéséhez.
Rfc2898DeriveBytes(String, Int32)	Elavult. Inicializálja az osztály új példányát a Rfc2898DeriveBytes jelszó és a sóméret használatával a kulcs levezetéséhez.

Tulajdonságok

Name	Description
HashAlgorithm	Lekéri a bájt származtatásához használt kivonatoló algoritmust.
IterationCount	Lekéri vagy beállítja a művelet iterációinak számát.
Salt	Lekéri vagy beállítja a művelet fő sóértékét.

Metódusok

Name	Description
CryptDeriveKey(String, String, Int32, Byte[])	Elavult. Titkosítási kulcsot hoz létre az Rfc2898DeriveBytes objektumból.
Dispose()	Ha egy származtatott osztályban felül van bírálva, az osztály aktuális példánya által használt összes erőforrást felszabadítja DeriveBytes . (Öröklődés forrása DeriveBytes)
Dispose(Boolean)	Felszabadítja az osztály által Rfc2898DeriveBytes használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetBytes(Int32)	Az objektum pszeudo-véletlenszerű kulcsát adja vissza.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Pbkdf2(Byte[], Byte[], Int32, HashAlgorithmName, Int32)	Létrehoz egy PBKDF2-alapú kulcsot jelszóbájtokból.
Pbkdf2(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32, HashAlgorithmName, Int32)	Létrehoz egy PBKDF2-alapú kulcsot jelszóbájtokból.
Pbkdf2(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, HashAlgorithmName)	A puffert PBKDF2 származtatott kulccsal tölti ki.
Pbkdf2(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32, HashAlgorithmName, Int32)	Létrehoz egy PBKDF2-alapú kulcsot egy jelszóból.
Pbkdf2(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Span<Byte>, Int32, HashAlgorithmName)	A puffert PBKDF2 származtatott kulccsal tölti ki.
Pbkdf2(String, Byte[], Int32, HashAlgorithmName, Int32)	Létrehoz egy PBKDF2-alapú kulcsot egy jelszóból.
Reset()	Alaphelyzetbe állítja a művelet állapotát.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Lásd még

• Titkosítási szolgáltatások